Back to project page Thrift-box.
The source code is released under:
GNU General Public License
If you think the Android project Thrift-box listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
package com.github.mikephil.charting.data; /*from w w w. java 2 s .co m*/ import android.content.Context; import android.graphics.Color; import com.github.mikephil.charting.utils.ColorTemplate; import java.util.ArrayList; /** * The DataSet class represents one group or type of entries (Entry) in the * Chart that belong together. It is designed to logically separate different * groups of values inside the Chart (e.g. the values for a specific line in the * LineChart, or the values of a specific group of bars in the BarChart). * * @author Philipp Jahoda */ public abstract class DataSet<T extends Entry> { /** arraylist representing all colors that are used for this DataSet */ protected ArrayList<Integer> mColors = null; /** the entries that this dataset represents / holds together */ protected ArrayList<T> mYVals = null; /** maximum y-value in the y-value array */ protected float mYMax = 0.0f; /** the minimum y-value in the y-value array */ protected float mYMin = 0.0f; /** the total sum of all y-values */ private float mYValueSum = 0f; /** label that describes the DataSet or the data the DataSet represents */ private String mLabel = "DataSet"; /** * Creates a new DataSet object with the given values it represents. Also, a * label that describes the DataSet can be specified. The label can also be * used to retrieve the DataSet from a ChartData object. * * @param yVals * @param label */ public DataSet(ArrayList<T> yVals, String label) { this.mLabel = label; this.mYVals = yVals; if (mYVals == null) mYVals = new ArrayList<T>(); // if (yVals.size() <= 0) { // return; // } mColors = new ArrayList<Integer>(); // default colors // mColors.add(Color.rgb(192, 255, 140)); // mColors.add(Color.rgb(255, 247, 140)); mColors.add(Color.rgb(140, 234, 255)); calcMinMax(); calcYValueSum(); } /** * Use this method to tell the data set that the underlying data has changed */ public void notifyDataSetChanged() { calcMinMax(); calcYValueSum(); } /** * calc minimum and maximum y value */ protected void calcMinMax() { if (mYVals.size() == 0) { return; } mYMin = mYVals.get(0).getVal(); mYMax = mYVals.get(0).getVal(); for (int i = 0; i < mYVals.size(); i++) { Entry e = mYVals.get(i); if (e.getVal() < mYMin) mYMin = e.getVal(); if (e.getVal() > mYMax) mYMax = e.getVal(); } } /** * calculates the sum of all y-values */ private void calcYValueSum() { mYValueSum = 0; for (int i = 0; i < mYVals.size(); i++) { mYValueSum += Math.abs(mYVals.get(i).getVal()); } } /** * returns the number of y-values this DataSet represents * * @return */ public int getEntryCount() { return mYVals.size(); } /** * Returns the value of the Entry object at the given xIndex. Returns * Float.NaN if no value is at the given x-index. INFORMATION: This method * does calculations at runtime. Do not over-use in performance critical * situations. * * @param xIndex * @return */ public float getYValForXIndex(int xIndex) { Entry e = getEntryForXIndex(xIndex); if (e != null) return e.getVal(); else return Float.NaN; } /** * Returns the first Entry object found at the given xIndex with binary * search. Returns null if no Entry object at that index. INFORMATION: This * method does calculations at runtime. Do not over-use in performance * critical situations. * * @param xIndex * @return */ public T getEntryForXIndex(int x) { int low = 0; int high = mYVals.size() - 1; while (low <= high) { int m = (high + low) / 2; if (x == mYVals.get(m).getXIndex()) { return mYVals.get(m); } if (x > mYVals.get(m).getXIndex()) low = m + 1; else high = m - 1; } return null; } /** * Returns all Entry objects at the given xIndex. INFORMATION: This method * does calculations at runtime. Do not over-use in performance critical * situations. * * @param xIndex * @return */ public ArrayList<T> getEntriesForXIndex(int x) { ArrayList<T> entries = new ArrayList<T>(); int low = 0; int high = mYVals.size(); while (low <= high) { int m = (high + low) / 2; if (x == mYVals.get(m).getXIndex()) { entries.add(mYVals.get(m)); } if (x > mYVals.get(m).getXIndex()) low = m + 1; else high = m - 1; } return entries; } /** * returns the DataSets Entry array * * @return */ public ArrayList<T> getYVals() { return mYVals; } /** * gets the sum of all y-values * * @return */ public float getYValueSum() { return mYValueSum; } /** * returns the minimum y-value this DataSet holds * * @return */ public float getYMin() { return mYMin; } /** * returns the maximum y-value this DataSet holds * * @return */ public float getYMax() { return mYMax; } /** * returns the type of the DataSet, specified via constructor * * @return */ // public int getType() { // return mType; // } /** * The xIndex of an Entry object is provided. This method returns the actual * index in the Entry array of the DataSet. IMPORTANT: This method does * calculations at runtime, do not over-use in performance critical * situations. * * @param xIndex * @return */ public int getIndexInEntries(int xIndex) { for (int i = 0; i < mYVals.size(); i++) { if (xIndex == mYVals.get(i).getXIndex()) return i; } return -1; } /** * Provides an exact copy of the DataSet this method is used on. * * @return */ public abstract DataSet<T> copy(); @Override public String toString() { StringBuffer buffer = new StringBuffer(); buffer.append(toSimpleString()); for (int i = 0; i < mYVals.size(); i++) { buffer.append(mYVals.get(i).toString() + " "); } return buffer.toString(); } /** * Returns a simple string representation of the DataSet with the type and * the number of Entries. * * @return */ public String toSimpleString() { StringBuffer buffer = new StringBuffer(); buffer.append("DataSet, label: " + mLabel + ", entries: " + mYVals.size() + "\n"); return buffer.toString(); } /** * Returns the label string that describes the DataSet. * * @return */ public String getLabel() { return mLabel; } /** * Adds an Entry to the DataSet dynamically. This will also recalculate the * current minimum and maximum values of the DataSet and the value-sum. * * @param d */ public void addEntry(Entry e) { if (e == null) return; float val = e.getVal(); if (mYVals == null || mYVals.size() <= 0) { mYVals = new ArrayList<T>(); mYMax = val; mYMin = val; } else { if (mYMax < val) mYMax = val; if (mYMin > val) mYMin = val; } mYValueSum += val; // add the entry mYVals.add((T) e); } /** * Removes an Entry from the DataSets entries array. This will also * recalculate the current minimum and maximum values of the DataSet and the * value-sum. Returns true if an Entry was removed, false if no Entry could * be removed. * * @param e */ public boolean removeEntry(T e) { if (e == null) return false; // remove the entry boolean removed = mYVals.remove(e); if (removed) { float val = e.getVal(); mYValueSum -= val; calcMinMax(); } return removed; } /** * Removes the Entry object that has the given xIndex from the DataSet. * Returns true if an Entry was removed, false if no Entry could be removed. * * @param xIndex */ public boolean removeEntry(int xIndex) { T e = getEntryForXIndex(xIndex); return removeEntry(e); } /** BELOW THIS COLOR HANDLING */ /** * Sets the colors that should be used fore this DataSet. Colors are reused * as soon as the number of Entries the DataSet represents is higher than * the size of the colors array. If you are using colors from the resources, * make sure that the colors are already prepared (by calling * getResources().getColor(...)) before adding them to the DataSet. * * @param colors */ public void setColors(ArrayList<Integer> colors) { this.mColors = colors; } /** * Sets the colors that should be used fore this DataSet. Colors are reused * as soon as the number of Entries the DataSet represents is higher than * the size of the colors array. If you are using colors from the resources, * make sure that the colors are already prepared (by calling * getResources().getColor(...)) before adding them to the DataSet. * * @param colors */ public void setColors(int[] colors) { this.mColors = ColorTemplate.createColors(colors); } /** * Sets the colors that should be used fore this DataSet. Colors are reused * as soon as the number of Entries the DataSet represents is higher than * the size of the colors array. You can use * "new int[] { R.color.red, R.color.green, ... }" to provide colors for * this method. Internally, the colors are resolved using * getResources().getColor(...) * * @param colors */ public void setColors(int[] colors, Context c) { ArrayList<Integer> clrs = new ArrayList<Integer>(); for (int color : colors) { clrs.add(c.getResources().getColor(color)); } mColors = clrs; } /** * Adds a new color to the colors array of the DataSet. * * @param color */ public void addColor(int color) { if (mColors == null) mColors = new ArrayList<Integer>(); mColors.add(color); } /** * Sets the one and ONLY color that should be used for this DataSet. * Internally, this recreates the colors array and adds the specified color. * * @param color */ public void setColor(int color) { resetColors(); mColors.add(color); } /** * returns all the colors that are set for this DataSet * * @return */ public ArrayList<Integer> getColors() { return mColors; } /** * Returns the color at the given index of the DataSet's color array. * Performs a IndexOutOfBounds check by modulus. * * @param index * @return */ public int getColor(int index) { return mColors.get(index % mColors.size()); } /** * Returns the first color (index 0) of the colors-array this DataSet * contains. * * @return */ public int getColor() { return mColors.get(0); } /** * Resets all colors of this DataSet and recreates the colors array. */ public void resetColors() { mColors = new ArrayList<Integer>(); } /** * Returns the position of the provided entry in the DataSets Entry array. * Returns -1 if doesnt exist. * * @param e * @return */ public int getEntryPosition(Entry e) { for (int i = 0; i < mYVals.size(); i++) { if (e.equalTo(mYVals.get(i))) return i; } return -1; } // /** // * Convenience method to create multiple DataSets of different types with // * various double value arrays. Each double array represents the data of // one // * DataSet with a type created by this method, starting at 0 (and // * incremented). // * // * @param yValues // * @return // */ // public static ArrayList<DataSet> makeDataSets(ArrayList<Double[]> // yValues) { // // ArrayList<DataSet> dataSets = new ArrayList<DataSet>(); // // for (int i = 0; i < yValues.size(); i++) { // // Double[] curValues = yValues.get(i); // // ArrayList<Entry> entries = new ArrayList<Entry>(); // // for (int j = 0; j < curValues.length; j++) { // entries.add(new Entry(curValues[j].floatValue(), j)); // } // // dataSets.add(new DataSet(entries, "DS " + i)); // } // // return dataSets; // } }