organicmaps/MPAndroidChart
13
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity Actions

Refactoring, tests and fixes related to min and max calculation

Browse source
This commit is contained in:
Philipp Jahoda 2016-06-07 14:00:45 +02:00
parent 33b158147e
commit ae2d917fa7
10 changed files with 179 additions and 156 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
MPChartExample/build.gradle
View file

@ -38,7 +38,7 @@ buildscript {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.1.0'
classpath 'com.android.tools.build:gradle:2.1.2'
//classpath 'io.realm:realm-gradle-plugin:0.88.2'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files

7
MPChartLib/src/main/java/com/github/mikephil/charting/components/YAxis.java
View file

@ -375,12 +375,5 @@ public class YAxis extends AxisBase {
// calc actual range
this.mAxisRange = Math.abs(this.mAxisMaximum - this.mAxisMinimum);
// // in case granularity is not customized, auto-calculate it
// if (!mCustomGranularity && mGranularityEnabled) {
//
// double granularity = Utils.granularity(mAxisRange, mLabelCount);
// this.mGranularity = (float) granularity;
// }
}
}

20
MPChartLib/src/main/java/com/github/mikephil/charting/data/BarDataSet.java
View file

@ -108,17 +108,13 @@ public class BarDataSet extends BarLineScatterCandleBubbleDataSet<BarEntry> impl
@Override
public void calcMinMax() {
if (mValues == null)
return;
if (mValues.size() == 0)
if (mValues == null || mValues.isEmpty())
return;
mYMax = Float.MIN_VALUE;
mYMin = Float.MAX_VALUE;
mYMax = -Float.MAX_VALUE;
mXMax = Float.MIN_VALUE;
mXMin = Float.MAX_VALUE;
mXMax = -Float.MAX_VALUE;
for (BarEntry e : mValues) {
@ -147,16 +143,6 @@ public class BarDataSet extends BarLineScatterCandleBubbleDataSet<BarEntry> impl
mXMax = e.getX();
}
}
if (mYMin == Float.MAX_VALUE) {
mYMin = 0.f;
mYMax = 0.f;
}
if(mXMin == Float.MAX_VALUE) {
mXMin = 0.f;
mXMax = 0.f;
}
}
@Override

20
MPChartLib/src/main/java/com/github/mikephil/charting/data/BubbleDataSet.java
View file

@ -31,17 +31,13 @@ public class BubbleDataSet extends BarLineScatterCandleBubbleDataSet<BubbleEntry
@Override
public void calcMinMax() {
if (mValues == null)
return;
if (mValues.size() == 0)
if (mValues == null || mValues.isEmpty())
return;
mYMax = Float.MIN_VALUE;
mYMin = Float.MAX_VALUE;
mYMax = -Float.MAX_VALUE;
mXMax = Float.MIN_VALUE;
mXMin = Float.MAX_VALUE;
mXMax = -Float.MAX_VALUE;
// need chart width to guess this properly
@ -75,16 +71,6 @@ public class BubbleDataSet extends BarLineScatterCandleBubbleDataSet<BubbleEntry
mMaxSize = size;
}
}
if (mYMin == Float.MAX_VALUE) {
mYMin = 0.f;
mYMax = 0.f;
}
if(mXMin == Float.MAX_VALUE) {
mXMin = 0.f;
mXMax = 0.f;
}
}
@Override

20
MPChartLib/src/main/java/com/github/mikephil/charting/data/CandleDataSet.java
View file

@ -102,17 +102,13 @@ public class CandleDataSet extends LineScatterCandleRadarDataSet<CandleEntry> im
@Override
public void calcMinMax() {
if (mValues == null)
return;
if (mValues.size() == 0)
if (mValues == null || mValues.isEmpty())
return;
mYMax = Float.MIN_VALUE;
mYMin = Float.MAX_VALUE;
mYMax = -Float.MAX_VALUE;
mXMax = Float.MIN_VALUE;
mXMin = Float.MAX_VALUE;
mXMax = -Float.MAX_VALUE;
for (CandleEntry e : mValues) {
@ -128,16 +124,6 @@ public class CandleDataSet extends LineScatterCandleRadarDataSet<CandleEntry> im
if (e.getX() > mXMax)
mXMax = e.getX();
}
if (mYMin == Float.MAX_VALUE) {
mYMin = 0.f;
mYMax = 0.f;
}
if(mXMin == Float.MAX_VALUE) {
mXMin = 0.f;
mXMax = 0.f;
}
}
/**

135
MPChartLib/src/main/java/com/github/mikephil/charting/data/ChartData.java
View file

@ -24,28 +24,29 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
/**
* maximum y-value in the value array across all axes
*/
protected float mYMax = 0.0f;
protected float mYMax = -Float.MAX_VALUE;
/**
* the minimum y-value in the value array across all axes
*/
protected float mYMin = 0.0f;
protected float mYMin = Float.MAX_VALUE;
/**
* maximum x-value in the value array
*/
protected float mXMax = 0f;
protected float mXMax = -Float.MAX_VALUE;
/**
* minimum x-value in the value array
*/
protected float mXMin = 0f;
protected float mXMin = Float.MAX_VALUE;
protected float mLeftAxisMax = Float.MIN_VALUE;
protected float mLeftAxisMax = -Float.MAX_VALUE;
protected float mLeftAxisMin = Float.MAX_VALUE;
protected float mRightAxisMax = Float.MIN_VALUE;
protected float mRightAxisMax = -Float.MAX_VALUE;
protected float mRightAxisMin = Float.MAX_VALUE;
@ -125,68 +126,57 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
*/
public void calcMinMax() {
if (mDataSets == null || mDataSets.size() < 1) {
if (mDataSets == null)
return;
mYMax = 0f;
mYMin = 0f;
mYMax = -Float.MAX_VALUE;
mYMin = Float.MAX_VALUE;
mXMax = -Float.MAX_VALUE;
mXMin = Float.MAX_VALUE;
mXMax = 0f;
mXMin = 0f;
for (T set : mDataSets) {
calcMinMax(set);
}
} else {
mLeftAxisMax = -Float.MAX_VALUE;
mLeftAxisMin = Float.MAX_VALUE;
mRightAxisMax = -Float.MAX_VALUE;
mRightAxisMin = Float.MAX_VALUE;
mYMin = Float.MAX_VALUE;
mYMax = -Float.MAX_VALUE;
// left axis
T firstLeft = getFirstLeft();
mXMin = Float.MAX_VALUE;
mXMax = -Float.MAX_VALUE;
if (firstLeft != null) {
for (int i = 0; i < mDataSets.size(); i++) {
mLeftAxisMax = firstLeft.getYMax();
mLeftAxisMin = firstLeft.getYMin();
T set = mDataSets.get(i);
calcMinMax(set);
}
for (IDataSet dataSet : mDataSets) {
if (dataSet.getAxisDependency() == AxisDependency.LEFT) {
if (dataSet.getYMin() < mLeftAxisMin)
mLeftAxisMin = dataSet.getYMin();
if (mYMin == Float.MAX_VALUE) {
mYMin = 0.f;
mYMax = 0.f;
}
// left axis
T firstLeft = getFirstLeft();
if (firstLeft != null) {
mLeftAxisMax = firstLeft.getYMax();
mLeftAxisMin = firstLeft.getYMin();
for (IDataSet dataSet : mDataSets) {
if (dataSet.getAxisDependency() == AxisDependency.LEFT) {
if (dataSet.getYMin() < mLeftAxisMin)
mLeftAxisMin = dataSet.getYMin();
if (dataSet.getYMax() > mLeftAxisMax)
mLeftAxisMax = dataSet.getYMax();
}
if (dataSet.getYMax() > mLeftAxisMax)
mLeftAxisMax = dataSet.getYMax();
}
}
}
// right axis
T firstRight = getFirstRight();
// right axis
T firstRight = getFirstRight();
if (firstRight != null) {
if (firstRight != null) {
mRightAxisMax = firstRight.getYMax();
mRightAxisMin = firstRight.getYMin();
mRightAxisMax = firstRight.getYMax();
mRightAxisMin = firstRight.getYMin();
for (IDataSet dataSet : mDataSets) {
if (dataSet.getAxisDependency() == AxisDependency.RIGHT) {
if (dataSet.getYMin() < mRightAxisMin)
mRightAxisMin = dataSet.getYMin();
for (IDataSet dataSet : mDataSets) {
if (dataSet.getAxisDependency() == AxisDependency.RIGHT) {
if (dataSet.getYMin() < mRightAxisMin)
mRightAxisMin = dataSet.getYMin();
if (dataSet.getYMax() > mRightAxisMax)
mRightAxisMax = dataSet.getYMax();
}
if (dataSet.getYMax() > mRightAxisMax)
mRightAxisMax = dataSet.getYMax();
}
}
}
@ -275,12 +265,12 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
public float getYMax(AxisDependency axis) {
if (axis == AxisDependency.LEFT) {
if (mLeftAxisMax == Float.MIN_VALUE) {
if (mLeftAxisMax == -Float.MAX_VALUE) {
return mRightAxisMax;
} else
return mLeftAxisMax;
} else {
if (mRightAxisMax == Float.MIN_VALUE) {
if (mRightAxisMax == -Float.MAX_VALUE) {
return mLeftAxisMax;
} else
return mRightAxisMax;
@ -325,6 +315,11 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
return mValueCount;
}
/**
* Returns all DataSet objects this ChartData object holds.
*
* @return
*/
public List<T> getDataSets() {
return mDataSets;
}
@ -578,23 +573,23 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
}
/**
* Removes the Entry object at the given xIndex from the DataSet at the
* Removes the Entry object closest to the given DataSet at the
* specified index. Returns true if an Entry was removed, false if no Entry
* was found that meets the specified requirements.
*
* @param xIndex
* @param xPos
* @param dataSetIndex
* @return
*/
public boolean removeEntry(int xIndex, int dataSetIndex) {
public boolean removeEntry(float xPos, int dataSetIndex) {
if (dataSetIndex >= mDataSets.size())
return false;
IDataSet dataSet = mDataSets.get(dataSetIndex);
Entry e = dataSet.getEntryForXPos(xIndex);
Entry e = dataSet.getEntryForXPos(xPos);
if (e == null || e.getX() != xIndex)
if (e == null)
return false;
return removeEntry(e, dataSetIndex);
@ -658,13 +653,14 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
return colors;
}
/**
* Returns the index of the provided DataSet in the DataSet array of this data object, or -1 if it does not exist.
*
* @param dataSet
* @return
*/
public int getIndexOfDataSet(T dataSet) {
for (int i = 0; i < mDataSets.size(); i++) {
if (mDataSets.get(i) == dataSet)
return i;
}
return -1;
return mDataSets.indexOf(dataSet);
}
/**
@ -678,7 +674,6 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
if (dataSet.getAxisDependency() == AxisDependency.LEFT)
return dataSet;
}
return null;
}
@ -693,7 +688,6 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
if (dataSet.getAxisDependency() == AxisDependency.RIGHT)
return dataSet;
}
return null;
}
@ -840,12 +834,15 @@ public abstract class ChartData<T extends IDataSet<? extends Entry>> {
}
/**
* Returns the DataSet object with the maximum number of entries.
* Returns the DataSet object with the maximum number of entries or null if there are no DataSets.
*
* @return
*/
public T getMaxEntryCountSet() {
if (mDataSets == null || mDataSets.isEmpty())
return null;
T max = mDataSets.get(0);
for (T set : mDataSets) {

39
MPChartLib/src/main/java/com/github/mikephil/charting/data/DataSet.java
View file

@ -22,22 +22,22 @@ public abstract class DataSet<T extends Entry> extends BaseDataSet<T> {
/**
* maximum y-value in the value array
*/
protected float mYMax = 0.0f;
protected float mYMax = -Float.MAX_VALUE;
/**
* minimum y-value in the value array
*/
protected float mYMin = 0.0f;
protected float mYMin = Float.MAX_VALUE;
/**
* maximum x-value in the value array
*/
protected float mXMax = 0.0f;
protected float mXMax = -Float.MAX_VALUE;
/**
* minimum x-value in the value array
*/
protected float mXMin = 0.0f;
protected float mXMin = Float.MAX_VALUE;
/**
@ -61,33 +61,16 @@ public abstract class DataSet<T extends Entry> extends BaseDataSet<T> {
@Override
public void calcMinMax() {
if (mValues == null)
if (mValues == null || mValues.isEmpty())
return;
if (mValues.size() == 0)
return;
mYMin = Float.MAX_VALUE;
mYMax = -Float.MAX_VALUE;
mXMin = Float.MAX_VALUE;
mYMin = Float.MAX_VALUE;
mXMax = -Float.MAX_VALUE;
mXMin = Float.MAX_VALUE;
for (T e : mValues) {
if (e != null && !Float.isNaN(e.getY())) {
calcMinMax(e);
}
}
if (mYMin == Float.MAX_VALUE) {
mYMin = 0.f;
mYMax = 0.f;
}
if (mXMin == Float.MAX_VALUE) {
mXMin = 0.f;
mXMax = 0.f;
calcMinMax(e);
}
}
@ -98,6 +81,9 @@ public abstract class DataSet<T extends Entry> extends BaseDataSet<T> {
*/
protected void calcMinMax(T e) {
if (e == null)
return;
if (e.getY() < mYMin)
mYMin = e.getY();
@ -225,8 +211,7 @@ public abstract class DataSet<T extends Entry> extends BaseDataSet<T> {
calcMinMax(e);
// add the entry
values.add(e);
return true;
return values.add(e);
}
@Override

82
MPChartLib/src/test/java/com/github/mikephil/charting/test/ChartDataTest.java
View file

@ -2,6 +2,8 @@ package com.github.mikephil.charting.test;
import com.github.mikephil.charting.components.YAxis;
import com.github.mikephil.charting.data.Entry;
import com.github.mikephil.charting.data.LineData;
import com.github.mikephil.charting.data.LineDataSet;
import com.github.mikephil.charting.data.ScatterData;
import com.github.mikephil.charting.data.ScatterDataSet;
@ -11,6 +13,7 @@ import java.util.ArrayList;
import java.util.List;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;
/**
* Created by philipp on 06/06/16.
@ -91,5 +94,84 @@ public class ChartDataTest {
assertEquals(-50f, data.getYMin(YAxis.AxisDependency.RIGHT), 0.01f);
assertEquals(200f, data.getYMax(YAxis.AxisDependency.RIGHT), 0.01f);
LineData lineData = new LineData();
assertEquals(Float.MAX_VALUE, lineData.getYMin(), 0.01f);
assertEquals(-Float.MAX_VALUE, lineData.getYMax(), 0.01f);
assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(Float.MAX_VALUE, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f);
assertEquals(-Float.MAX_VALUE, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f);
assertEquals(0, lineData.getDataSetCount());
List<Entry> lineEntries1 = new ArrayList<Entry>();
lineEntries1.add(new Entry(10, 90));
lineEntries1.add(new Entry(1000, 1000));
LineDataSet lineSet1 = new LineDataSet(lineEntries1, "");
lineData.addDataSet(lineSet1);
assertEquals(1, lineData.getDataSetCount());
assertEquals(2, lineSet1.getEntryCount());
assertEquals(2, lineData.getEntryCount());
assertEquals(10, lineData.getXMin(), 0.01f);
assertEquals(1000f, lineData.getXMax(), 0.01f);
assertEquals(90, lineData.getYMin(), 0.01f);
assertEquals(1000, lineData.getYMax(), 0.01f);
assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(90, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f);
assertEquals(1000, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f);
List<Entry> lineEntries2 = new ArrayList<Entry>();
lineEntries2.add(new Entry(-1000, 2000));
lineEntries2.add(new Entry(2000, -3000));
Entry e = new Entry(-1000, 2500);
lineEntries2.add(e);
LineDataSet lineSet2 = new LineDataSet(lineEntries2, "");
lineSet2.setAxisDependency(YAxis.AxisDependency.RIGHT);
lineData.addDataSet(lineSet2);
assertEquals(2, lineData.getDataSetCount());
assertEquals(3, lineSet2.getEntryCount());
assertEquals(5, lineData.getEntryCount());
assertEquals(-1000, lineData.getXMin(), 0.01f);
assertEquals(2000, lineData.getXMax(), 0.01f);
assertEquals(-3000, lineData.getYMin(), 0.01f);
assertEquals(2500, lineData.getYMax(), 0.01f);
assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(-3000, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f);
assertEquals(2500, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f);
assertTrue(lineData.removeEntry(e, 1));
assertEquals(-1000, lineData.getXMin(), 0.01f);
assertEquals(2000, lineData.getXMax(), 0.01f);
assertEquals(-3000, lineData.getYMin(), 0.01f);
assertEquals(2000, lineData.getYMax(), 0.01f);
assertEquals(90, lineData.getYMin(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(1000f, lineData.getYMax(YAxis.AxisDependency.LEFT), 0.01f);
assertEquals(-3000, lineData.getYMin(YAxis.AxisDependency.RIGHT), 0.01f);
assertEquals(2000, lineData.getYMax(YAxis.AxisDependency.RIGHT), 0.01f);
}
}

8
MPChartLib/src/test/java/com/github/mikephil/charting/test/DataSetTest.java
View file

@ -45,6 +45,14 @@ public class DataSetTest {
assertEquals(10f, set.getYMax(), 0.01f);
assertEquals(4, set.getEntryCount());
set.removeEntry(3);
assertEquals(10f, set.getXMin(), 0.01f);
assertEquals(21, set.getXMax(), 0.01f);
assertEquals(2f, set.getYMin(), 0.01f);
assertEquals(10f, set.getYMax(), 0.01f);
}
@Test

2
build.gradle
View file

@ -7,7 +7,7 @@ buildscript {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.1.0'
classpath 'com.android.tools.build:gradle:2.1.2'
classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'
}
}