Autore Topic: Plotting di grafici con aChartEngine  (Letto 2102 volte)

Offline valfa

  • Nuovo arrivato
  • *
  • Post: 5
  • Respect: 0
    • Mostra profilo
Plotting di grafici con aChartEngine
« il: 05 Luglio 2011, 17:49:01 CEST »
0
Salve a tutti,
ho la necessita' di plottare un grafico di natura analogica...proiettato nel tempo

L'asse delle y sono microVolt
mentre l'asse delle x e' il tempo espresso in secondi.
Dalle mie novizie ricerche nel mondo android ho conosciuto 3/4 librerie grafiche che vengono utilizzate per i charts, la mia attenzione si e' fermata sul progretto achartengine (achartengine-0.6.0.jar)
scaricando la demo credo faccia al caso mio, mi sono subito messo a leggere il codice degli esempi e a buttare giu' una prima classe di test che usasse le funzioni di base (NON ESSENDOCI UN TUTORIAL...)
Ora mi trovo fermo su dei problemi...
NON riesco a costringere il grafico con RANGE FISSI sia di Y che di X che non cambino con il tach o con lo scroll orizzontale che ho implementato in automatico...

Vorrei nel mio caso che i valori prodotti venissero plottati per quanto riguarda le Y
ad esempio le Y da -1.5 a 1.5  divisi in sotto unita' di 0.5
e le X da 0 a 20 in sotto unita' di 0.2

Come posso fare questo?
Soprattutto quando con il Touch mi sposto in orizzontale nel grafico l'asse delle X viene risuddiviso arbitrariamente ( ad esempio in due o in tre parti)....
ECCO IO VORREI CONTROLLARE POPRIO QUESTO FENOMENO!
vorrei che anche spostandomi a destra in orizzontale ed incrementando i valori delle X l'asse venga sempre e comunque suddiviso in 0,2  0,4 0,6 .............10,2 10,4 10,6.......15,2... etc etc.

posto il mio codice:
Codice: [Seleziona]
package com.artfulbits.aiCharts.ECGGraphSample;

import java.util.Random;

import org.achartengine.GraphicalView;
import org.achartengine.chart.LineChart;
import org.achartengine.chart.PointStyle;
import org.achartengine.model.RangeCategorySeries;
import org.achartengine.model.XYMultipleSeriesDataset;
import org.achartengine.model.XYSeries;
import org.achartengine.model.XYValueSeries;
import org.achartengine.renderer.XYMultipleSeriesRenderer;
import org.achartengine.renderer.XYSeriesRenderer;
import org.achartengine.tools.Pan;

import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import android.view.View;
import android.widget.HorizontalScrollView;
import android.widget.ScrollView;

/**
 *
 *
 */
public class MainActivity2 extends Activity {

        private GraphicalView view;

        /**
         *
         */
        private XYMultipleSeriesRenderer renderer = new XYMultipleSeriesRenderer();

        /**
     *
     */
        private XYMultipleSeriesDataset dataset = new XYMultipleSeriesDataset();

        /**
     *
     */
        private XYSeries xyseries = new XYSeries("?");

        /**
         *
         */
        private Pan pan;
       
        /**
         *
         */
        public MainActivity2() {
        }

        /**
         *
         */
        private void init()
        {
                renderer.setAxisTitleTextSize(16);
                renderer.setChartTitleTextSize(20);
                renderer.setLabelsTextSize(15);
                renderer.setLegendTextSize(15);
                renderer.setPointSize(5f);
                renderer.setMargins(new int[] { 20, 30, 15, 0 });
                //
                XYSeriesRenderer r = new XYSeriesRenderer();
                r.setColor( Color.BLUE);
                r.setPointStyle( PointStyle.POINT);
                renderer.addSeriesRenderer(r);               
                //
                renderer.setShowGrid(true);
                renderer.setXTitle("mm/sec");
                renderer.setYTitle("mm/V");
                renderer.setYAxisMin(-1.5);
                renderer.setYAxisMax(1.5);
                renderer.setXAxisMin(0);
                renderer.setXAxisMax(20);
                //
                renderer.setAxesColor(Color.GRAY);
                renderer.setLabelsColor(Color.LTGRAY);
                renderer.setPanEnabled(true, false);
                //
                xyseries = new XYValueSeries("DATA");
                xyseries.add(0, 0);
                dataset.addSeries(xyseries);
                //
                if (dataset == null
                                || renderer == null
                                || dataset.getSeriesCount() != renderer
                                                .getSeriesRendererCount())
                        throw new IllegalArgumentException(
                                        "Dataset and renderer should be not null and should have the same number of series");
                //
        }
       
        /**
         *
         */
        @Override
        protected void onCreate(Bundle savedInstanceState) {
                // TODO Auto-generated method stub
                super.onCreate(savedInstanceState);
                init();
                LineChart chart=new LineChart(dataset, renderer);
                pan = new Pan(chart);
                view = new GraphicalView(this,chart);
                setContentView(view);
        }
       
        /**
         *
         */
        @Override
        protected void onStart()
        {
                super.onStart();
                new PaintThread().start();
        }
       
        /**
         *
         * @param xyseries
         */
        public void addData(double d1, double d2) {
                xyseries.add(d1, d2);
        }
       
        /**
         *
         */
        public void scroll()
        {
                //apply(float oldX, float oldY, float newX, float newY)
                pan.apply((float)xyseries.getMaxX(),(float)xyseries.getMaxY(),0,(float)xyseries.getMaxY());
        }
       
       
        /**
         *
         * @author alfarano
         *
         */
        private class PaintThread extends Thread {
               
                /**
                 *
                 */
                double y = xyseries.getMaxY();
               
                /**
                 *
                 */
                double x = xyseries.getMaxX();

                /**
                 *
                 */
                public PaintThread()
                {
                }
               
                /**
                 *
                 * @param microVolt
                 */
                private void addSamples(int[] microVolt)
                {
                        for (int i = 0; i < microVolt.length; i++)
                        {
                                addData(x +(5+i), microVolt[i]);
                        }
                        view.repaint();
                        x = xyseries.getMaxX();
                }
               
                /**
                 * 480 pixel
                 *
                 * per rappresentare un quadrato 5 pixel
                 *
                 * 1 quadrato = 0,2 sec
                 *
                 * 480 pixel = 480/5 = 96 quadratini
                 *
                 * 96 * 0,2 = 19,2 sec
                 *
                 */
                public void run() {
                        while (true) {
                       
                                int[] samples =new int[100];
                                for(int i=0;i<samples.length;i++)
                                {
                                        samples[i]=new Random().nextInt(10);
                                }
                                //
                                addSamples(samples);
                                //
                                SystemClock.sleep(1000);
                                if(x>0 && ((x % view.getWidth())==0))
                                {
                                                scroll();
                                                Log.d(">>", ">>> Scroll! ");
                                }
                                Log.d(">>", ">>> x ="+x+" w="+view.getWidth());
                                //Log.d(">>", ">> REPAINT!");
                        }
                }
        }
}

Alcune spiegazioni sul codice per aiutarvi;
  • e' una simulazione del plotting di valori ricevuti in input...la generazione di tali valori viene fatta con l'oggetto Random (ma questo non e' importante)
  • Al''interno viene lanciato un Thread che ha il compito di aggiungere dinamicamente valori nuovi da plottare con un refresh di 1 secondo (repaint())
  • Con un controllo delle cooridinate X mi accorgo di quando ho raggiunto con il valore di X un multiplo della alrghezza dello schermo ed in questo caso mi sposto a destra per continuare a rendere visibile nel grafico il plotting su ccordinate future..
  • Nei commenti troverete un minimo ragionamento da me fatto che si basa sul plotting in base alla risoluzione dello schermo in pixel:
    In Particolare se la larghezza e' 480 pixel
    Per rappresentare una unita' temporale uso 5 pixel (x+5+i)  avro' 480/5 = 96  unita' temporali; poi decido che ogni unita' temporale vale 0,2 secondi
    quindi ad ogni schermata posso plottare i valori proiettati in 96 * 0,2 = 19,2 sec, ipotizzando ad esempio di ricevere dalla rete 100 valori al secondoin una schermata posso plottare 100 * 19,2 = 1920 valori.
  • Pan che e' l'oggetto che mi permette di spostarmi nel grafico e' stato settato in maniera da permettere di muoversi solo lungo le X e non le Y come del resto serve a me...

Grazie a tutti per la disponibilita' e mi scuso per essermi dilungato ma mi serve una soluzione urgentemente e non ho voglia di plottare tutti in 2d con Canvas Paint etc etc etc

ciao 8-)

Offline AngelMagli

  • Nuovo arrivato
  • *
  • Post: 18
  • Respect: 0
    • Mostra profilo
Re:Plotting di grafici con aChartEngine
« Risposta #1 il: 21 Dicembre 2012, 11:00:26 CET »
0
Ciao,
posso sapere come hai risolto questo problema? Mi sto trovando nella stessa situazione! non riesco a far spostare automaticamente il grafico lungo l'asse X!
Grazie mille per eventuali suggerimenti
Distinti Saluti.