protected void setChartSettings(
     XYMultipleSeriesRenderer mXYMultipleSeriesRenderer,
     String xTitle,
     String yTitle,
     double xMin,
     double xMax,
     double yMin,
     double yMax,
     int axesColor,
     int labelsColor) {
   // 有关对图表的渲染可参看api文档
   mXYMultipleSeriesRenderer.setChartTitle(title);
   mXYMultipleSeriesRenderer.setXTitle(xTitle);
   mXYMultipleSeriesRenderer.setYTitle(yTitle);
   mXYMultipleSeriesRenderer.setXAxisMin(xMin);
   mXYMultipleSeriesRenderer.setAxisTitleTextSize(30);
   mXYMultipleSeriesRenderer.setChartTitleTextSize(50);
   mXYMultipleSeriesRenderer.setLabelsTextSize(15);
   mXYMultipleSeriesRenderer.setXAxisMax(xMax);
   mXYMultipleSeriesRenderer.setYAxisMin(yMin);
   mXYMultipleSeriesRenderer.setYAxisMax(yMax);
   mXYMultipleSeriesRenderer.setAxesColor(axesColor);
   mXYMultipleSeriesRenderer.setLabelsColor(labelsColor);
   mXYMultipleSeriesRenderer.setShowGrid(true);
   mXYMultipleSeriesRenderer.setGridColor(Color.GRAY);
   mXYMultipleSeriesRenderer.setXLabels(20);
   mXYMultipleSeriesRenderer.setYLabels(10);
   mXYMultipleSeriesRenderer.setXTitle("time");
   mXYMultipleSeriesRenderer.setYLabelsAlign(Align.RIGHT);
   mXYMultipleSeriesRenderer.setPointSize((float) 5);
   mXYMultipleSeriesRenderer.setShowLegend(true);
   mXYMultipleSeriesRenderer.setLegendTextSize(20);
 }
 private void setChartSettings(XYMultipleSeriesRenderer renderer) {
   renderer.setChartTitle("Chart demo");
   renderer.setXTitle("x values");
   renderer.setYTitle("y values");
   renderer.setXAxisMin(0.5);
   renderer.setXAxisMax(10.5);
   renderer.setYAxisMin(0);
   renderer.setYAxisMax(210);
 }
 public void init() {
   mRenderer.setMarginsColor(Color.argb(0x00, 0xff, 0x00, 0x00)); // transparent margins
   mRenderer.setPanEnabled(false, false);
   mRenderer.setYAxisMax(-40);
   mRenderer.setYAxisMin(-100);
   mRenderer.setYLabels(3);
   mRenderer.setYTitle(LABEL_Y);
   mRenderer.setXAxisMin(0);
   mRenderer.setXAxisMax(300);
   mRenderer.setXLabels(15);
   mRenderer.setXTitle(LABEL_X);
   mRenderer.setShowGrid(true);
   mRenderer.setShowLabels(true);
   mRenderer.setShowLegend(false);
   mRenderer.setShowCustomTextGrid(true);
 }
  protected void setChartSettings(XYMultipleSeriesRenderer renderer) {
    double xMin, xMax, yMin = 5, yMax = 40;

    // 有关对图表的渲染可参看api文档
    renderer.setAxisTitleTextSize(16);
    renderer.setChartTitleTextSize(16);
    renderer.setLabelsTextSize(15);
    renderer.setLegendTextSize(15);

    renderer.setXTitle("时间 (月/日 时:分)");
    renderer.setYTitle("温度 (摄氏度)");
    renderer.setChartTitle(title);

    // XY轴的最大/最小值
    // renderer.setXAxisMin(xMin);
    // renderer.setXAxisMax(xMax);
    renderer.setYAxisMin(yMin);
    renderer.setYAxisMax(yMax);

    // 坐标轴颜色
    renderer.setAxesColor(Color.RED);
    // 标签(title、单位)颜色
    renderer.setLabelsColor(Color.WHITE);
    // 网格属性
    renderer.setShowGrid(true);
    renderer.setGridColor(Color.BLACK);
    // 背景色 不起作用
    // renderer.setBackgroundColor(Color.WHITE);

    // 横纵坐标格数
    renderer.setXLabels(5);
    renderer.setYLabels((int) ((yMax - yMin) / 5));
    // Y轴的刻度到Y轴的右边
    renderer.setYLabelsAlign(Align.RIGHT);
    // 折线转折点大小
    renderer.setPointSize((float) 7);
    // 是否显示图例
    renderer.setShowLegend(false);
    // 显示折线转折点值
    // renderer.setDisplayChartValues(true);
  }
Exemple #5
0
 /**
  * Sets a few of the series renderer settings.
  *
  * @param renderer the renderer to set the properties to
  * @param title the chart title
  * @param xTitle the title for the X axis
  * @param yTitle the title for the Y axis
  * @param xMin the minimum value on the X axis
  * @param xMax the maximum value on the X axis
  * @param yMin the minimum value on the Y axis
  * @param yMax the maximum value on the Y axis
  * @param axesColor the axes color
  * @param labelsColor the labels color
  */
 public void setChartSettings(
     XYMultipleSeriesRenderer renderer,
     String title,
     String xTitle,
     String yTitle,
     double xMin,
     double xMax,
     double yMin,
     double yMax,
     int axesColor,
     int labelsColor) {
   renderer.setChartTitle(title);
   renderer.setXTitle(xTitle);
   renderer.setYTitle(yTitle);
   renderer.setXAxisMin(xMin);
   renderer.setXAxisMax(xMax);
   renderer.setYAxisMin(yMin);
   renderer.setYAxisMax(yMax);
   renderer.setAxesColor(axesColor);
   renderer.setLabelsColor(labelsColor);
 }
  @Override
  public void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    mDataCache = DataCache.getInstance();

    mDataset = new XYMultipleSeriesDataset();
    mRenderer = new XYMultipleSeriesRenderer();
    // Renderer
    // Basic
    mRenderer.setMargins(new int[] {100, 150, 30, 100});
    mRenderer.setChartTitleTextSize(20);
    mRenderer.setApplyBackgroundColor(true);
    mRenderer.setBackgroundColor(0xffE8E8E7);
    mRenderer.setMarginsColor(0xffE8E8E7);
    mRenderer.setLegendTextSize(15);
    mRenderer.setPointSize(5);
    mRenderer.setShowLegend(true);
    mRenderer.setClickEnabled(false);
    // Axes
    mRenderer.setAxisTitleTextSize(50);
    mRenderer.setBarSpacing(50);
    mRenderer.setYTitle("Light");
    // mRenderer.setAxesColor(Color.BLACK);
    // Labels
    // mRenderer.setLabelsColor(Color.WHITE);
    mRenderer.setLabelsTextSize(35);
    mRenderer.setXLabels(0);
    mRenderer.setYLabels(10);
    mRenderer.setYAxisMin(0);
    mRenderer.setYAxisMax(1000);
    mRenderer.setXLabelsColor(Color.BLACK);
    mRenderer.setYLabelsColor(0, Color.BLACK);
    mRenderer.setXLabelsAngle(-45f);
    mRenderer.setXLabelsAlign(Align.CENTER);
    mRenderer.setYLabelsAlign(Align.RIGHT);

    mRenderer.setPanEnabled(false, false);
    mRenderer.setZoomEnabled(false, false);
  }
Exemple #7
0
  private void updateUI() {

    Weather weather = sensor.getLatestWeatherObject();

    if (weather != null) {
      humidity.setText(weather.getHumidity().toString());
      barometric.setText(weather.getBarometricKPA().toString());
      temperature.setText(weather.getTemperatureF().toString());

      if (weather.getTemperatureF() != 0) {

        tempArray.add(weather.getTemperatureF());

        if (tempArray.size() >= MAX_POINTS) {
          tempArray.remove(tempArray.size() - MAX_POINTS);
        }

        tempSeries.clear();
        int j = 0; // zero base our index regardless of position
        for (Double point : tempArray) {
          tempSeries.add(j, point);
          j++;
        }

        Double value = weather.getTemperatureF();

        if (tempMax - tempMin < 1) {
          tempMax = value + 1;
          tempMin = value - 1;

          tempRenderer.setYAxisMin(tempMin);
          tempRenderer.setYAxisMax(tempMax);
        } else {
          if (value < tempMin) {
            tempMin = value;
            tempRenderer.setYAxisMin(tempMin);
          }
          if (value > tempMax) {
            tempMax = value;
            tempRenderer.setYAxisMax(tempMax);
          }
        }

        tempChartView.repaint();
      }

      if (weather.getHumidity() != 0) {

        humiArray.add(weather.getHumidity());

        if (humiArray.size() >= MAX_POINTS) {
          humiArray.remove(humiArray.size() - MAX_POINTS);
        }

        humiSeries.clear();
        int j = 0; // zero base our index regardless of position
        for (Double point : humiArray) {
          humiSeries.add(j, point);
          j++;
        }

        Double value = weather.getHumidity();

        if (value < humiMin) {
          humiMin = value;
          humiRenderer.setYAxisMin(humiMin);
        }
        if (value > humiMax) {
          humiMax = value;
          humiRenderer.setYAxisMax(humiMax);
        }
        if (humiMin == humiMax) {
          humiMax = value + 1;
          humiMin = value - 1;

          humiRenderer.setYAxisMin(humiMin);
          humiRenderer.setYAxisMax(humiMax);
        }

        humiChartView.repaint();
      }

      if (weather.getHumidity() != 0) {

        presArray.add(weather.getBarometricKPA());

        if (presArray.size() >= MAX_POINTS) {
          presArray.remove(presArray.size() - MAX_POINTS);
        }

        presSeries.clear();
        int j = 0; // zero base our index regardless of position
        for (Double point : presArray) {
          presSeries.add(j, point);
          j++;
        }

        Double value = weather.getBarometricKPA();

        if (value < presMin) {
          presMin = value;
          presRenderer.setYAxisMin(presMin);
        }
        if (value > presMax) {
          presMax = value;
          presRenderer.setYAxisMax(presMax);
        }
        if (presMin == presMax) {
          presMax = value + 1;
          presMin = value - 1;

          presRenderer.setYAxisMin(presMin);
          presRenderer.setYAxisMax(presMax);
        }

        presChartView.repaint();
      }
    }
  }
Exemple #8
0
  private void collectFuelStats(int v, Cursor fuelCursor) {
    long MILLIPERDAY = 1000 * 60 * 60 * 24;
    long DAYSPERYEAR = 365;
    long MONPERYEAR = 12;
    float tare = 0;
    prevDist = 0;
    Double sumC = 0d;
    Double sumE = 0d;
    Double y0Min;
    Double y0Max;
    Double y1Min;
    Double y1Max;
    float cost_per_day;
    long days;
    float total_cost;
    int count = 0;

    // need 2 or more datapoints to analyze fuel usage. The first one
    // we'll use the odometer reading as tare and ignore fuel/qty/price for average.
    // at the second filling and beyond, we then can calculate fuel usage relative to
    // cost and price and distance
    if (fuelCursor.getCount() > 2) {
      fuelCursor.moveToFirst(); // discard this one except for dist, which is starting
      int numData =
          0; // fuelCursor.getCount()-2; // start at the end since this is time based and fill
             // backward

      float dist = fuelCursor.getFloat(fuelCursor.getColumnIndex(mDbHelper.KEY_DIST));
      long first_day = fuelCursor.getLong(fuelCursor.getColumnIndex(mDbHelper.KEY_DATE));
      long last_day;
      tare = dist;
      total_cost = 0;
      fuelCursor.moveToNext();
      do {
        Long date = fuelCursor.getLong(fuelCursor.getColumnIndex(mDbHelper.KEY_DATE));
        int ddate = (int) ((today - date) / millisecPerDay);
        Log.d("GAS:", "numData: ddate=" + numData + " : " + ddate);
        float cost = fuelCursor.getFloat(fuelCursor.getColumnIndex(mDbHelper.KEY_COST));
        float price = fuelCursor.getFloat(fuelCursor.getColumnIndex(mDbHelper.KEY_PRICE));
        float qty = fuelCursor.getFloat(fuelCursor.getColumnIndex(mDbHelper.KEY_QTY));
        float thisDist = fuelCursor.getFloat(fuelCursor.getColumnIndex(mDbHelper.KEY_DIST));
        last_day = fuelCursor.getLong(fuelCursor.getColumnIndex(mDbHelper.KEY_DATE));
        float delta = thisDist - tare;
        float efficiency = delta / qty;
        float costperd = (price * qty) / delta;

        mCurrentCostSeries.add(date, costperd);
        mCurrentEffSeries.add(date, efficiency);
        sumC += costperd;
        sumE += efficiency;
        total_cost += cost;
        count++;

        tare = thisDist; // just get distance per fuel filling

        numData++;
      } while (fuelCursor.moveToNext());

      String fs, fsm, fsy;
      float dailyCost = total_cost / (float) ((last_day - first_day) / MILLIPERDAY);
      float yearlyCost = dailyCost * DAYSPERYEAR;
      fs = String.format("%.1f /day  ", dailyCost);
      fsy = String.format("%.0f/yr", yearlyCost);
      mDailyCost.setText("Average Cost " + cunits + fs + cunits + fsy);

      avgCost = sumC / count;

      fs = String.format(avgCostTitle + ":" + "%.1f", avgCost);
      mRenderer.addYTextLabel(avgCost, fs, 0);

      avgEff = sumE / count;
      fs = String.format(avgEffTitle + ":" + "%.1f", avgEff);
      mRenderer.addYTextLabel(avgEff, fs, 1);

      y0Min = mCurrentCostSeries.getMinY();
      y0Max = mCurrentCostSeries.getMaxY();

      y1Min = mCurrentEffSeries.getMinY();
      y1Max = mCurrentEffSeries.getMaxY();

      // set up chart min/max so that charts aren't scrunched together
      mRenderer.setYAxisMin(y0Min - (y0Max - y0Min) / 2, 0);
      mRenderer.setYAxisMax(y0Max + (y0Max - y0Min) / 2, 0);

      // set the efficiency to be lower
      mRenderer.setYAxisMin(0, 1);
      mRenderer.setYAxisMax(y1Max + (y1Max - y1Min) / 2, 1);

    } else {
      // no data. barf on user
      Toast.makeText(
              this,
              getApplicationContext().getResources().getString(R.string.nodata_err),
              Toast.LENGTH_SHORT)
          .show();
    }
  }
  private void setupTopChart() {

    // Creating an  XYSeries for Sound
    visitsSeries = new XYSeries("");
    secondSeries = new XYSeries("");

    // Creating a dataset to hold each series
    dataset = new XYMultipleSeriesDataset();
    Sdataset = new XYMultipleSeriesDataset();

    // Adding Visits Series to the dataset
    dataset.addSeries(visitsSeries);
    Sdataset.addSeries(secondSeries);

    // Adding datasets together
    multiDateSet = new XYMultipleSeriesDataset();
    multiDateSet.addSeries(visitsSeries);
    multiDateSet.addSeries(secondSeries);

    // Creating XYSeriesRenderer to customize visitsSeries
    visitsRenderer = new XYSeriesRenderer();
    visitsRenderer.setColor(getResources().getColor(R.color.colorAccent));
    visitsRenderer.setPointStyle(PointStyle.CIRCLE);
    visitsRenderer.setFillPoints(true);
    visitsRenderer.setDisplayChartValues(false);
    visitsRenderer.setLineWidth(10);

    // Creating a XYMultipleSeriesRenderer to customize the whole chart
    multiRenderer = new XYMultipleSeriesRenderer();

    multiRenderer.setMargins(new int[] {0, 0, 0, 0});
    multiRenderer.setPanEnabled(false);
    multiRenderer.setShowLegend(false);
    multiRenderer.setChartTitle("");
    // multiRenderer.setFitLegend(true);

    // Eliminate the S***e
    multiRenderer.setApplyBackgroundColor(true);
    multiRenderer.setXTitle("");
    multiRenderer.setShowLabels(false);
    multiRenderer.setShowAxes(false);

    multiRenderer.setMarginsColor(Color.TRANSPARENT);
    multiRenderer.setBackgroundColor(Color.TRANSPARENT);
    multiRenderer.setXLabelsColor(Color.TRANSPARENT);
    multiRenderer.setYLabelsColor(0, Color.TRANSPARENT);
    multiRenderer.setGridColor(Color.TRANSPARENT);
    multiRenderer.setXLabelsPadding(0);
    multiRenderer.setYLabelsPadding(0);
    multiRenderer.setBarWidth(100);

    // Establish Beginning Dimensions
    multiRenderer.setXAxisMin(0);
    multiRenderer.setXAxisMax(10);
    multiRenderer.setYAxisMin(0);
    multiRenderer.setYAxisMax(0);

    // Make the bar graphs touching
    multiRenderer.setBarSpacing(0);

    // Adding visitsRenderer to multipleRenderer
    // Note: The order of adding dataseries to dataset and renderers to multipleRenderer
    // should be same
    multiRenderer.addSeriesRenderer(visitsRenderer);
    multiRenderer.addSeriesRenderer(visitsRenderer);

    // Getting a reference to LinearLayout of the RecordActivity Layout
    LinearLayout chartContainer = (LinearLayout) findViewById(R.id.chartTop);

    mChart =
        (GraphicalView)
            ChartFactory.getBarChartView(
                getBaseContext(),
                multiDateSet,
                multiRenderer,
                org.achartengine.chart.BarChart.Type.DEFAULT);

    // Adding the Line Chart to the LinearLayout
    chartContainer.addView(mChart);
  }
  private void openChart() {

    String[] chartTitles;
    chartTitles = new String[] {"Total"};
    List<double[]> values = new ArrayList<double[]>();
    values.add(mStatsDataDaysList.getDataDoubleArray());
    int totalXlength = 0;

    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();

    List<double[]> xAxisValues = new ArrayList<double[]>();
    xAxisValues.add(mStatsDataDaysList.getXDoubleArray());

    for (int i = 0; i < chartTitles.length; i++) {
      XYSeries series = new XYSeries(chartTitles[i]);
      double[] xV = xAxisValues.get(i);
      double[] yV = values.get(i);
      int seriesLength = xV.length;
      for (int k = 0; k < seriesLength; k++) {
        System.out.println("LOG X is " + xV[k] + " y is " + yV[k]);
        series.add(xV[k] - 1, yV[k]);
      }
      dataset.addSeries(series);
    }

    XYSeriesRenderer incomeRenderer = new XYSeriesRenderer();
    incomeRenderer.setColor(Color.WHITE);
    incomeRenderer.setPointStyle(PointStyle.CIRCLE);
    incomeRenderer.setFillPoints(true);
    incomeRenderer.setDisplayChartValues(true);
    incomeRenderer.setDisplayChartValuesDistance(15);
    incomeRenderer.setDisplayBoundingPoints(false); // for hiding the series when we scroll

    // Creating a XYMultipleSeriesRenderer to customize the whole chart
    XYMultipleSeriesRenderer multiRenderer = new XYMultipleSeriesRenderer();
    multiRenderer.setChartTitle(getString(R.string.my_mined_km_history));
    multiRenderer.setXTitle(getString(R.string.days));
    multiRenderer.setYTitle(getString(R.string.km));
    multiRenderer.setZoomButtonsVisible(true);
    multiRenderer.setBackgroundColor(0xf7f7f7);
    multiRenderer.setMarginsColor(0xf7f7f7);
    multiRenderer.setMargins(new int[] {50, 60, 60, 30});

    multiRenderer.setXLabelsAlign(Align.CENTER);
    multiRenderer.setYLabelsAlign(Align.RIGHT);
    multiRenderer.setPanEnabled(true, false); // scroll only x axis so true
    multiRenderer.setZoomEnabled(ZOOM_X, false);

    multiRenderer.setPointSize(8); // increase the width of point size
    multiRenderer.setXLabelsPadding(10);

    if (Utils.getScreenDendity(this) > DisplayMetrics.DENSITY_HIGH) {
      multiRenderer.setAxisTitleTextSize(20);
      multiRenderer.setChartTitleTextSize(25);
      multiRenderer.setLabelsTextSize(20);
      multiRenderer.setPointSize(8);
      incomeRenderer.setLineWidth(4);
      incomeRenderer.setChartValuesTextSize(20);
    } else {
      multiRenderer.setAxisTitleTextSize(12);
      multiRenderer.setChartTitleTextSize(18);
      multiRenderer.setLabelsTextSize(12);
      multiRenderer.setPointSize(5);
      incomeRenderer.setLineWidth(2);
      incomeRenderer.setChartValuesTextSize(15);
    }

    xyValues = new LinkedHashMap<Integer, String>();

    for (int i = 0; i < chartTitles.length; i++) {
      double[] xV = xAxisValues.get(i);
      totalXlength = xV.length;
      System.out.println("LOG len is " + totalXlength);
      for (int j = 0; j < totalXlength; j++) {
        multiRenderer.addXTextLabel(j + 1, Utils.addDays(xV[j], mInitialDateUser));
        xyValues.put(j + 1, Utils.addDays(xV[j], mInitialDateUser));
      }
    }

    multiRenderer.setXLabels(0);
    multiRenderer.setShowAxes(false);

    multiRenderer.setXAxisMin(totalXlength - 5);
    multiRenderer.setXAxisMax(totalXlength + 1);

    if (totalXlength <= X_AXIS_MAX) {
      multiRenderer.setXAxisMin(0);
      multiRenderer.setXAxisMax(totalXlength);
    }

    multiRenderer.setPanEnabled(true);
    multiRenderer.setPanLimits(new double[] {0, totalXlength + 1, 0, 0});

    multiRenderer.setYAxisMin(Utils.getMinValueFromList(values));
    multiRenderer.setYAxisMax(Utils.getMaxValueFromList(values));
    multiRenderer.setAxesColor(Color.GRAY);
    multiRenderer.setLabelsColor(Color.WHITE);
    multiRenderer.addSeriesRenderer(incomeRenderer);

    // Creating a Time Chart
    mChartView2 =
        (GraphicalView)
            ChartFactory.getTimeChartView(getBaseContext(), dataset, multiRenderer, "dd-MMM-yyyy");

    multiRenderer.setClickEnabled(true);
    multiRenderer.setSelectableBuffer(10);

    // Setting a click event listener for the graph
    mChartView2.setOnClickListener(
        new View.OnClickListener() {

          @Override
          public void onClick(View v) {

            SeriesSelection seriesSelection = mChartView2.getCurrentSeriesAndPoint();
            double[] xy = mChartView2.toRealPoint(0);

            if (seriesSelection != null) {

              //                  debug
              Log.d("Punto", seriesSelection.getXValue() + ", " + seriesSelection.getValue());
              //                  debug
              Log.d(
                  "Chart point",
                  "Chart element in series index "
                      + seriesSelection.getSeriesIndex()
                      + " data point index "
                      + seriesSelection.getPointIndex()
                      + " was clicked"
                      + " closest point value X="
                      + seriesSelection.getXValue()
                      + ", Y="
                      + seriesSelection.getValue()
                      + " clicked point value X="
                      + (float) xy[0]
                      + ", Y="
                      + (float) xy[1]);

              Toast.makeText(
                      getBaseContext(),
                      ""
                          + xyValues.get((int) seriesSelection.getXValue())
                          + " , "
                          + seriesSelection.getValue()
                          + " "
                          + getString(R.string.km),
                      Toast.LENGTH_SHORT)
                  .show();
            }
          }
        });

    // Adding the Line Chart to the LinearLayout
    mLayoutChart2.addView(mChartView2);
  }
  @Override
  protected void onStart() {
    // TODO Auto-generated method stub
    super.onStart();

    try {
      elec_thread.join();
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    int k = CH.getNum_of_msg(); // 보여줄 데이터 개수

    Log.d("get", "onStart시작");

    int seriesLength = 0;
    double max = 0;

    recv_packet = new Packet[k];

    for (int i = 0; i < k; i++) {
      recv_packet[i] = CH.get_Packet(i);
    }
    Log.d("get", "recv_packet배열 저장");

    List<Float[]> values = new ArrayList<Float[]>();
    Float[][] a = new Float[4][k];
    int[][] c = new int[4][k];

    for (int j = 0; j < k; j++) {
      a[0][j] = Float.parseFloat(recv_packet[j].getData(3));
      a[1][j] = Float.parseFloat(recv_packet[j].getData(4));
      a[2][j] = Float.parseFloat(recv_packet[j].getData(5));
      a[3][j] = Float.parseFloat(recv_packet[j].getData(7));
      c[0][j] = (int) (a[0][j] * 10);
      c[1][j] = (int) (a[1][j] * 10);
      c[2][j] = (int) (a[2][j] * 10);
      c[3][j] = (int) (a[3][j] * 10);
      a[0][j] = ((float) c[0][j] / (float) 10);
      a[1][j] = ((float) c[1][j] / (float) 10);
      a[2][j] = ((float) c[2][j] / (float) 10);
      a[3][j] = ((float) c[3][j] / (float) 10);

      // a[3][j] = (float) Math.round(Float.parseFloat(recv_packet[j].getData(7))*10000)/10000;
      // values.add(a);// 이번달
    }
    for (int w = 0; w < 4; w++) {
      //        a[w] = Math.round(a[w]*10) / 10.0;
      values.add(a[w]);
    }

    Log.d("get", "values배열 저장");
    XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();

    renderer.setChartTitle("과거 사용량과의 비교");
    renderer.setChartTitleTextSize(50);

    String[] titles = new String[] {"3달 전", "2달 전", "1달 전", "이번 달"};

    int[] colors =
        new int[] {
          Color.rgb(255, 90, 217),
          Color.rgb(54, 255, 255),
          Color.rgb(255, 255, 72),
          Color.rgb(83, 255, 76)
        };
    // //////////////////////////////////////////////////////
    //   renderer.setLegendTextSize(35);

    int length = values.size(); // 항목갯수

    Log.d("get", "legnth : " + length);
    for (int i = 0; i < length; i++) {
      SimpleSeriesRenderer r = new SimpleSeriesRenderer();
      r.setColor(colors[i]);
      renderer.addSeriesRenderer(r);
    }

    renderer.setXTitle("제품별");
    renderer.setYTitle("사용량");
    renderer.setAxisTitleTextSize(28);
    renderer.setMarginsColor(Color.WHITE);

    renderer.setLabelsTextSize(20);
    renderer.setLegendHeight(200);
    renderer.setXAxisMin(0.5);
    // renderer.setXAxisMax(length + 0.5); // 장비 갯수 +0.5
    renderer.setYAxisMin(0);

    renderer.setLabelsColor(Color.BLACK);
    renderer.setBackgroundColor(Color.WHITE);

    // 그래프 위에 값 표시하기
    for (int i = 0; i < length; i++) {
      renderer.getSeriesRendererAt(i).setDisplayChartValues(true);
      renderer.getSeriesRendererAt(i).setChartValuesTextAlign(Align.RIGHT);
      renderer.getSeriesRendererAt(i).setChartValuesTextSize(20);
    }
    Log.d("get", "그래프위값 표시하기");

    renderer.setYLabels(5);

    // x,y축 정렬 방향
    renderer.setXLabelsAlign(Align.CENTER);
    renderer.setYLabelsAlign(Align.CENTER);
    renderer.setPanEnabled(true, true); // x,y축 스크롤 여부 on/off
    renderer.setZoomEnabled(true); // zoom기능 on/off
    renderer.setZoomRate(1.0f);
    renderer.setBarSpacing(0.5f);

    Log.d("get", "xy축 정렬 방향");

    XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();
    for (int i = 0; i < titles.length; i++) {
      CategorySeries series = new CategorySeries(titles[i]);
      Float[] v = values.get(i);

      Log.d("get", "int i = 0; i < titles.length; i++");

      seriesLength = v.length;
      renderer.setXAxisMax(seriesLength + 0.5);

      for (int q = 0; q < seriesLength; q++) {
        series.add(v[q]);
        if (max < v[q]) {
          max = v[q];
        }
        // Log.d("Test", "series.add : " + v[q]);
        renderer.setXLabels(seriesLength + 1);
      }
      dataset.addSeries(series.toXYSeries());
    }
    Log.d("get", "111111111");
    String[] x_name = new String[seriesLength];
    for (int b = 0; b < k; b++) {
      x_name[b] = recv_packet[b].getData(2);
    }
    Log.d("get", "222222222");
    renderer.setXLabels(0);
    for (int i = 0; i < seriesLength; i++) {
      renderer.addXTextLabel(i + 1, x_name[i]);
    }
    renderer.setYAxisMax(max + (max * 0.1)); // max 찾아서 넣기
    GraphicalView gv = ChartFactory.getBarChartView(this, dataset, renderer, Type.DEFAULT);

    setContentView(gv);
  }
Exemple #12
0
  public static View genBarChart(final Activity activity, final BarChartData data) {
    if (data == null || data.getData() == null) return null;
    Resources resources = activity.getResources();
    final String[] axis_x_string = resources.getStringArray(R.array.week);
    final XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();
    XYMultipleSeriesDataset dataSet = new XYMultipleSeriesDataset();
    renderer.setApplyBackgroundColor(true);
    renderer.setBackgroundColor(Color.WHITE);
    renderer.setMarginsColor(Color.WHITE);
    renderer.setTextTypeface(null, Typeface.NORMAL);

    renderer.setShowGrid(true);
    renderer.setGridColor(resources.getColor(R.color.gray3));

    renderer.setLabelsColor(Color.BLACK);
    renderer.setAxesColor(resources.getColor(R.color.gray1));
    renderer.setBarSpacing(0.5);

    renderer.setXTitle("");
    renderer.setYTitle("");
    renderer.setXLabelsColor(Color.BLACK);
    renderer.setLabelsTextSize(
        activity.getResources().getDimensionPixelSize(R.dimen.ov_statistics_axis_text_size));
    renderer.setYLabelsColor(0, Color.BLACK);
    renderer.setXLabelsPadding(resources.getDimension(R.dimen.ov_statistics_x_axis_padding));
    renderer.setYLabelsPadding(resources.getDimension(R.dimen.ov_statistics_x_axis_padding));
    renderer.setXLabelsAlign(Paint.Align.CENTER);
    renderer.setYLabelsAlign(Paint.Align.CENTER);
    renderer.setXLabelsAngle(0);
    renderer.setShowTickMarks(false);

    renderer.setXLabels(0);
    renderer.setYAxisMin(0);

    for (int i = 0; i < data.getData().length; i++) {
      final XYSeries series = new XYSeries("");
      dataSet.addSeries(series);
      XYSeriesRenderer yRenderer = new XYSeriesRenderer();
      renderer.addSeriesRenderer(yRenderer);
      yRenderer.setColor(resources.getColor(data.sColorId[i]));
      series.add(0, 0);
      renderer.addXTextLabel(0, "");
      for (int j = 0; j < data.getData()[i].length; j++) {
        renderer.addXTextLabel(j + 1, axis_x_string[j]);
        series.add(j + 1, ((float) data.getData()[i][j]) / 3600000);
      }
      series.add(data.getData()[i].length + 1, 0);
      renderer.addXTextLabel(data.getData()[i].length + 1, "");
    }

    renderer.setZoomEnabled(false);
    renderer.setZoomEnabled(false, false);
    renderer.setClickEnabled(true);
    renderer.setPanEnabled(false);
    renderer.setShowLegend(false);
    try {
      renderer.setDrawGridAfterBar(true);
      renderer.setHighLightRectEnabled(true);
      renderer.setHighLightRectStrokeWidth(
          activity
              .getResources()
              .getDimensionPixelOffset(R.dimen.ov_statistics_highlight_stroke_width));
      renderer.setHighLightRectStrokeColor(activity.getResources().getColor(R.color.gray3));
    } catch (NoSuchMethodError e) {
      e.printStackTrace();
    }
    View view = ChartFactory.getBarChartView(activity, dataSet, renderer, BarChart.Type.DEFAULT);
    view.setOnClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            if (!(v instanceof GraphicalView)) return;
            final GraphicalView view = (GraphicalView) v;
            SeriesSelection selection = view.getCurrentSeriesAndPoint();
            try {
              view.onClick(selection);
            } catch (NoSuchMethodError e) {
              e.printStackTrace();
            }
            if (selection == null) return;
            int idx = selection.getPointIndex() - 1;
            View popupView = activity.getLayoutInflater().inflate(R.layout.bar_chart_popup, null);
            if (data.from.equals(CaseOverviewFragment.class.getSimpleName())
                || data.from.equals(EquipmentOverviewFragment.class.getSimpleName())) {
              ((TextView) popupView.findViewById(R.id.date)).setText(data.getDate()[idx]);
              if (data.getData()[0][idx] >= 0) {
                int hour = (int) data.getData()[0][idx] / 3600000;
                int min = (int) ((data.getData()[0][idx] % 3600000)) / 60000;
                ((TextView) popupView.findViewById(R.id.working_time))
                    .setText(
                        activity.getResources().getString(R.string.statistics_popup_time_finish)
                            + " "
                            + (hour < 10 ? ("0" + hour) : hour)
                            + " : "
                            + (min < 10 ? ("0" + min) : min));
              } else {
                popupView.findViewById(R.id.vg_working_time).setVisibility(View.GONE);
              }
              popupView.findViewById(R.id.vg_overtime).setVisibility(View.GONE);
            } else if (data.from.equals(WorkerOverviewFragment.class.getSimpleName())) {
              ((TextView) popupView.findViewById(R.id.date)).setText(data.getDate()[idx]);
              if (data.getData()[0][idx] >= 0) {
                int hour = (int) data.getData()[0][idx] / 3600000;
                int min = (int) ((data.getData()[0][idx] % 3600000)) / 60000;
                ((TextView) popupView.findViewById(R.id.working_time))
                    .setText(
                        activity.getResources().getString(R.string.statistics_popup_time_work)
                            + " "
                            + (hour < 10 ? ("0" + hour) : hour)
                            + " : "
                            + (min < 10 ? ("0" + min) : min));
              } else {
                popupView.findViewById(R.id.vg_working_time).setVisibility(View.GONE);
              }
              if (data.getData()[1][idx] >= 0) {
                int hour = (int) data.getData()[1][idx] / 3600000;
                int min = (int) ((data.getData()[1][idx] % 3600000)) / 60000;
                ((TextView) popupView.findViewById(R.id.overtime))
                    .setText(
                        activity.getResources().getString(R.string.statistics_popup_time_overtime)
                            + " "
                            + (hour < 10 ? ("0" + hour) : hour)
                            + " : "
                            + (min < 10 ? ("0" + min) : min));
              } else {
                popupView.findViewById(R.id.vg_overtime).setVisibility(View.GONE);
              }
            }
            final PopupWindow popup =
                new PopupWindow(
                    popupView,
                    LinearLayout.LayoutParams.WRAP_CONTENT,
                    LinearLayout.LayoutParams.WRAP_CONTENT);
            popup.setBackgroundDrawable(new BitmapDrawable());
            popup.setOutsideTouchable(true);
            popup.setOnDismissListener(
                new PopupWindow.OnDismissListener() {
                  @Override
                  public void onDismiss() {
                    try {
                      view.onClick(null);
                    } catch (NoSuchMethodError e) {
                      e.printStackTrace();
                    }
                  }
                });
            /* calculate popup position */
            popupView.measure(
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED));
            int[] dateChooserLocations = new int[2];
            (activity.findViewById(R.id.ov_statistics_week_chooser))
                .getLocationOnScreen(dateChooserLocations);
            int[] statisticsViewLocations = new int[2];
            v.getLocationOnScreen(statisticsViewLocations);
            int[] barChartLocations = new int[2];
            v.getLocationOnScreen(barChartLocations);
            int x_pos =
                barChartLocations[0]
                    + (int) ((XYChart) view.getChart()).getXAxisPos((double) (idx + 1))
                    - popupView.getMeasuredWidth() / 2;
            int y_base =
                dateChooserLocations[1]
                    + (activity.findViewById(R.id.ov_statistics_week_chooser)).getMeasuredHeight();
            int y_pos =
                (statisticsViewLocations[1] - y_base) / 2
                    + y_base
                    - popupView.getMeasuredHeight() / 2;
            popup.showAtLocation(v, Gravity.NO_GRAVITY, x_pos, y_pos);
          }
        });
    return view;
  }
  // the zephry manager will send RR values to this listener.
  // RRs are the milliseconds between beats.  Example, steady 60 BPM heartbeat sends rr values of
  // 1000 because there is a full second between beats
  public void updateChart(int rr) {

    // we throw out any 0s or absurd values.  We have found this tends not to happen with a good
    // chest strap
    if ((rr < 1) || (rr > 3000)) return;
    int pulserate = 60000 / rr;
    series.add(x, pulserate);
    x = x + rr; // time is also the accumulation of RR values

    // Achartengine stuff
    XYSeriesRenderer renderer = new XYSeriesRenderer();
    XYMultipleSeriesRenderer mRenderer = new XYMultipleSeriesRenderer();

    // Set the right side to current time
    mRenderer.setXAxisMax(x);

    // set the left side to one minute earlier 60000 miliseconds
    mRenderer.setXAxisMin(x - 60000);

    mRenderer.setYAxisMin(MIN_HEART_RATE);
    mRenderer.setYAxisMax(MAX_HEART_RATE);

    mRenderer.setLabelsTextSize(LABELTEXTSIZE);
    renderer.setFillPoints(true);
    renderer.setLineWidth(2);

    renderer.setPointStyle(style);
    mRenderer.setShowLegend(false);
    mRenderer.setChartTitle(title);
    mRenderer.setShowGrid(true);
    mRenderer.setGridColor(gridcolor);
    mRenderer.setXLabels(11);
    mRenderer.setYLabels(5);

    mRenderer.setAxisTitleTextSize(25);
    mRenderer.setChartTitleTextSize(30);
    mRenderer.setLabelsTextSize(20);
    mRenderer.setLegendTextSize(15);
    mRenderer.setPointSize(2f);
    mRenderer.setMargins(new int[] {20, 30, 15, 0});

    mRenderer.setYLabelsAlign(Align.RIGHT);
    mDataset.removeSeries(0);

    mDataset.addSeries(series);

    renderer.setColor(linecolor);
    context = getApplicationContext();
    mRenderer.setApplyBackgroundColor(true);
    mRenderer.setBackgroundColor(bgcolor);
    mRenderer.addSeriesRenderer(renderer);

    chartview = ChartFactory.getTimeChartView(context, mDataset, mRenderer, null);
    chartview.invalidate();
    ((TextView) findViewById(R.id.heartratelabel)).setText("HR:" + pulserate);

    chartview.repaint();

    FrameLayout chartlayout = (FrameLayout) findViewById(R.id.chartlayout);
    chartlayout.removeAllViewsInLayout();

    chartlayout.addView(
        chartview,
        new FrameLayout.LayoutParams(
            FrameLayout.LayoutParams.FILL_PARENT, FrameLayout.LayoutParams.FILL_PARENT));

    status
        .checkForClear(); // this needs to be done time to time regularly so statuses are not stuck
                          // on.
  }