Newsgroup: it.comp.java
Titolo: Grafici con valori di tipo double

 Carmine
 
Sinceramente non molto, non ho capito se ti riferisci a immagini oppure a
grafici da fare con valori in entrata(dici una cosa nel subject e un'altra
nel post).
Se fosse la seconda potresti fare una cosa del genere:
*******************************************
double[] data = new double[_quello che serve_];
//riempito con i dati che servono
public void paintComponent(Graphics g)
{
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
double xmin = 0; //il numero minimo di dati inseriti
double xmax = ....; // il numero massimo di dati inseriti + 2 
double ymin = ...; //il valore minimo nei dati che estrai (di solito 0
                  //in caso di numeri solo positivi , se no il minimo dei 
                  //numeri negativi)
double ymax = ...; //il valore massimo nei dati che estrai ( + un certo
                  //valore a tua scelta)
/* la parte bella del programma.*/
double xscale = (this.getWidth() - 1.0) / (xmax - xmin);
double yscale = (this.getHeight() - 1.0) / (ymin - ymax);
g2.scale(xscale, yscale);
g2.translate(-xmin, -ymax);
/*fine parte bella*/
g2.setStroke(new BasicStroke(0.1f));
/*a questo punto ti crei quello che vuoi, per es.:*/
double x = 1;
 for (int i = 0; i < data.length; i++)
 { 
  Line2D line = new Line2D.Double(x, 0, x, data[i]);
  g2.draw(line);
  x++; 
 }
}
*******************************************************
Di solito calcolo xmax come xmax = data.length + 2; .
Per avere ymin e ymax conviene creare dei metodi che estraggano il valore
massimo e minimo da l'array data(è una cosa piuttosto semplice), stando
attenti che se il valore del minimo  è positivo ymin dovrà essere cmq zero
(altrimenti viene un pastrocchio), al valore massimo si dovrà aggiungere
"qualcosa" (che devi decidere tu in base alla tua "sensibilità artistica").
La parte "bella" sfrutta due equazione per portare i valori delle coordinate
in scala con i valori di entrata ( siccome non so come mettere i pedici non
inserisco le equazioni).
Ricordati anche che se estendi qlc componente devi fissare delle dimensioni
(per es.: con un JPanel dovresti fare 
this.setPreferredSize(new Dimension(300, 300)); )
p.s. non è frutto delle mie meningi, ma l'ho preso paro paro dall'Horstmann,
ma lo uso sempre per fare grafici a barre.
-- 
Ciao. Fabrizio.
(icq:241182067) 
http://groups.yahoo.com/group/jug_brescia/
< MISTAH KURTZ -- HE DEAD.
   A penny for the Old Guy>  (T.S. Elliot: the hollow men)

 Spero di essere stato il + chiaro possibile!
Non sei stato abbastanza chiaro, almeno per me :-)
Tiro a indovinare: devi disegnare un grafico su un piano cartesiano
partendo da una serie di valori (che siano presi da db o calcolati
cambia poco) e quindi il tuo problema consiste nel translare le
coordinate logiche in coordinate fisiche (pixel) ?
Hai dei vincoli sulla dimensione dell'immagine che devi creare ?
Ciao,
Andrea

 Carmine
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Sono stato piu' chiaro adesso???
Sì, un po' :-)
1) stabilisci un'altezza massima in pixel delle immagini, chiamala H
2) ricavi il valore massimo della serie di valori che devi
    rappresentare, chiamalo MAX
3) per comodità stabiliamo che H=100 e MAX=7.654, calcoli un fattore di
    moltiplicazione K=H/MAX => 100/7.654=13.065064 che usiamo per
    calcolare le altezze delle immagini.
4) a questo punto a 5.138 corrisponde un'altezza di 67 (5.138*K =>
    5.138*13.065064=67.128299, che arrotondiamo a 67 perchè i pixel
    non sono divisibili), a 5.124 corrisponde un'altezza di...
    sempre 67 ( 5.124*K => 5.124*13.065064=66.945388 che arrotondiamo a
    67), a questo punto hai un problema, due valori diversi generano
    immagini di altezza uguale. Il problema si può risolvere in modi
    diversi:
    a) oltre a MAX ricavi anche MIN e K lo calcoli come K=H/(MAX-MIN) e
       l'altezza delle immagini la calcoli come (x-MIN)*K.
       Se MIN=4.321 => K=100/3.333=30.003 e ottieni:
       5.138 => altezza=(5.138-4.321)*30.003=24.512451
       5.124 => altezza=(5.124-4.321)*30.003=24.092409
       ma anche così a due valori diversi corrisponde, dopo
       l'arrotondamento, la stessa altezza. Mannaggia non funziona !
       La differenza tra due valori è troppo bassa, dobbiamo inventarci
       qualcos'altro.
Riproviamoci:
1) non stabilisci a priori un'altezza massima ma un delta minimo DP (in
    pixel) che permetta di percepire la differenza tra due altezze
    diverse, ad esempio DP=2 pixel
2) calcoli il delta minimo DV fra i valori che devi rappresentare (hint:
    sort), nel caso dei tre valori che hai portato ad esempio:
    5.138-5.124 = 0.014
    5.124-5.01  = 0.114
    DV=0.014
    ricavi il massimo MAX e il minimo MIN della serie dei valori (oppure
    li stabilisci arbitrariamente basandoti più o meno sui minimi e
    massimi, ad esempio MAX=valore_massimo+1 e MIN=valore_minimo-1)
3) a questo punto puoi calcolare l'altezza massima H delle immagini
    come (MAX-MIN/0.014)*DP
    Se MAX=7 e MIN=4 => H=(3/0.014)*2=428.57
    Se H è troppo alto o troppo basso puoi agire su DP
4) a questo punto procedi come prima: calcoli il fattore di
    moltiplicazione: K=H/(MAX-MIN) => K=428.57/(7-4)= 142.85667
    a questo punto l'altezza delle immagini (calcolata sempre come
    altezza=(x-MIN)*K) diventa:
       5.138 => altezza=(5.138-3)*142.85667= 305.42755 => 305
       5.124 => altezza=(5.124-3)*142.85667= 303.42757 => 303
       5.01  => altezza=(5.01-3)*142.85667 = 287.14191 => 287
       Puff ! Ce l'abbiamo fatta ad avere una differenza di almeno
       2 pixel !
Un'ulteriore variante potrebbe essere quella di applicare scale
diverse a range diversi (DP=0.5 per valori compresi tra 0 e 100 e DP=3
per valori compresi tra 100 e 105, ad esempio), ma questo introduce
altra complessità.
A questo punto spero di esser stato abbastanza chiaro io :-)
Non escludo che ci possano essere dei metodi più furbi, purtroppo non li
conosco.
Ciao