PDA

Visualizza la versione completa : [Java] lettura coordinate da file di testo


Neds
23-06-2005, 18:29
Salve,
dovrei scrivere un programma che ha in input un file punti.txt:

3.25 2.47 //coordinate primo punto
2.87 1.71 // secondo punto
3.24 2.66 // terzo punto
.... //probabili altri punti

e un file cerchi.txt

3.14 2.41 0.55 //coordinate cerchio (x, y, raggio)
2.11 8.99 0.49
1.11 1.84 0.33
....
il prog deve leggere la prima riga del file punti.txt
memorizzarla come coordinate x y del primo punto, confrontarle con le coordinate del cerchio (confronta se il punto è contenuto nel cerchio)
se il punto è contenuto nel cerchio viene aggiunto al file output.txt che alla fine del prog sarà circa:

punto 1(x, y)contenuto in:
cerchio1(x,y,raggio)
cerchio2(x,y,raggio).

punto2(x, y)contenuto in:
cerchio4(x,y,raggio).
ecc...

ogni file punti.txt e cerchi.txt può contenere un numero qualsiasi di coordinate

il mio problema è:
come far leggere il punti.txt e cerchi.txt "riga a riga"
e come convertire le righe in stringhe e memorizzarle (in modo da poterle convertire in coordinate e confrontarle) :bhò:


spero che qualcuno possa aiutarmi (aiutooo)
PS: non riesco a trovare una guida o altro che tratti l'elaborazione di file, se qualcuno potesse darmi qualche link
grazie

Wave
23-06-2005, 19:14
uno dei metodi che si possono usare è:

PER SCRIVERE:

1) crei un oggetto della classe FileWriter associato al nome del file


FileWriter file = new FileWriter("prova.txt");

2) crei un oggetto di tipo PrintWriter associato all'oggetto FileWriter che hai creato precedentemente


PrintWriter file2 = new PrintWriter(file);

3) scrivi il testo sul file con il metodo println dell'oggetto PrintWriter


file2.println("quello che vuoi scrivere");

4) chiudi il file lanciando il metodo .close() sull'oggetto PrintWriter


file2.close();


PER LEGGERE:

1) crei un oggetto della classe FileReader associato al nome del file


FileReader file = new FileReader("prova.txt");

2) crei un oggetto di tipo BufferReader associato all'oggetto FileReader che hai creato precedentemente


BufferReader file2 = new BufferReader(file);

3) Leggi le righe del file con il metodo readLine dell'oggetto BufferReader


file2.readLine();

4) chiudi il file lanciando il metodo .close() sull'oggetto BufferReader


file2.close();

questi sono i metodi che usavo io quando facevo gli esercizi all'università....il file che creavo o leggevo era nella stessa cartella del file .java che eseguiva il programma....non mi sono mai posto il problema di come fare se il file si fosse trovato altrove.....

lascio la parola ai più esperti....

spero di esserti stato di aiuto.

P.S. okkio anche alla gestione delle eccezzioni IOException.....

Wave
23-06-2005, 21:35
un'altra cosa...mi sono dimenticato di dirti che devi importare il package java.io.* per usare le classi che ti ho scritto sopra....

e ho cercato un attimo e invece che il metodo readLine() penso ti sia più utile il metodo read() che legge un solo carattere alla volta (ma restituisce un dato di tipo int) e restituisce -1 ogni volta che arriva alla fine della riga...

in questo modo puoi lanciare un .read() per 4 volte sul file per ottenere una coordinata.

ricordati che il lancio del metodo sarà una cosa di questo tipo:



FileReader file = TUTTTA_LA_PAPPA_CHE_TI_HO_SCRITTO_SOPRA ;
int carattere_int = file.read();
char carattere;
if (carattere_int != -1)
carattere = (char) carattere_int;


spero di essermi spiegato bene

Matteo982
23-06-2005, 22:51
ma devi per forza usare file di tipo testo o era solo un esempio?

Wave
23-06-2005, 22:52
mi sono accorto adesso di un errore sul primo post:

la classe è BufferedReader e NON BufferReader....

sorry...

ciao ciao

Neds
24-06-2005, 10:36
@matteo 982: si devo usare solo file di testo
@wave: credo(anzi spero) di aver capito, ora provo,
grazie
PS: se il file da aprire o creare non si trova nella stessa cartella basta mettere il percorso(ricordati delle doppie barre rovesciate
<< FileWriter file = new FileWriter("metti//il//percorso//del//file//prova.txt"); >>
:ciauz:

Neds
24-06-2005, 16:12
import java.io.*;

public class Cluster {
public static void main(String args[])
{
try{
// preparo i file input/output
FileReader inputcluster = new FileReader("cluster.txt");
BufferedReader cluster = new BufferedReader(inputcluster);

FileReader inputcerchi = new FileReader("cerchi.txt");
BufferedReader cerchi = new BufferedReader(inputcerchi);

FileWriter fileOutput = new FileWriter("output.txt");
PrintWriter output = new PrintWriter(fileOutput);


// lettura della riga di coordinate dei punti (da cluster.txt)
String cPunto = cluster.readLine();
String[] coordinataP = cPunto.split("\\s");

//converto in double
double xPunto = Double.parseDouble(coordinataP[0]);
double yPunto = Double.parseDouble(coordinataP[1]);

//preparo l'output
output.println("Cluster (" + xPunto + " " + yPunto + "): ");



//lettura di coordinate da cerchi.txt
String cCerchio = cerchi.readLine();
String[] coordinataC = cCerchio.split("\\s");

// conversione in double delle coordinate
double xCerchio = Double.parseDouble(coordinataC[0]);
double yCerchio = Double.parseDouble(coordinataC[1]);
double rCerchio = Double.parseDouble(coordinataC[2]);

// verifica se il cerchio contiene il punto
// calcolanto la distanza tra il centro del cerchio e il punto
double distanza = pitagora(xPunto, yPunto, xCerchio, yCerchio);
// se la distanza è minore o uguale al raggio
// il cerchio contiene il punto
if (distanza <= rCerchio)
output.println(xCerchio + " , " + yCerchio + " raggio: " + rCerchio);



output.close();

}
catch (IOException e){
System.out.println("Errore: " + e);}
}


public static double pitagora(double xPunto, double yPunto, double xCerchio, double yCerchio)
{
return (Math.rqst(((xPunto - xCerchio) * (xPunto - xCerchio)) + ((yPunto - yCerchio) * (yPunto - yCerchio))));
}

}

Il codice che ho scritto è imperfetto, perchè legge e confronta solo la
prima riga, dovrei mettere un doppio ciclo che mi legge il punto, legge
il cerchio, confronta le coordinate, legge un altro cerchio, confronta
le coordinate, finiti i cerchi legge un altro punto e riparte con la
lettura e il confronto con i cerchi.
cosa uso per mettere un ciclo?


inoltre, dovrei stampare anche ogni cluster(punto) e le coordinate del
cerchio più vicino per ognuno, cosa posso fare per memorizzare (e non
solamente stampare) i cerchi che contengono il punto?(non c'è un numero
predefinito di cerchi e punti, quindi dovrebbe essere una soluzione
adatta) in modo che poi posso trovare il più vicino?

scusate le richieste che potranno essere banali, ma sono alle prime armi
e questo esercizio era un pò più laborioso degli altri che ho fatto fin'ora

Grazie dell'aiuto che mi avete dato fino ad ora(spero che mi aiuterete anche per quest'altre cose) :)

Andrea1979
24-06-2005, 18:34
bhè, visto che devi fare tutte quelle cose, io rivedrei un pochino la struttura del programma, dividendo in classi (tipo Punto, Cerchio etc.), caricando i vari punti in un array di Punto e i vari cerchi in un array di Cerchio, a quel punto fai un po' quel che vuoi... una cosa del genere



import java.io.*;
import java.util.*;

class Punto {
private double x;
private double y;

public double getX() {
return x;
}

public double getY() {
return y;
}

public Punto(String coordinate) {
StringTokenizer st = new StringTokenizer(coordinate);
x = Double.parseDouble((String)st.nextElement());
y = Double.parseDouble((String)st.nextElement());
}

}

class Cerchio {

private double x;
private double y;
private double radius;

public double getX() {
return x;
}

public double getY() {
return y;
}

public double getRadius() {
return radius;
}

public Punto getCenter() {
return new Punto(getX()+" "+getY());
}

public Cerchio(String coordinate) {
StringTokenizer st = new StringTokenizer(coordinate);
x = Double.parseDouble((String)st.nextElement());
y = Double.parseDouble((String)st.nextElement());
radius = Double.parseDouble((String)st.nextElement());
}
}


public class demo {

File cerchi;
File punti;
Punto[] p;
Cerchio[] c;

private void carica(File f) {
try {
String curr;
String out="";
BufferedReader bfr = new BufferedReader(new FileReader(f));
while ((curr = bfr.readLine()) != null) {
out += curr+"\n";
}
StringTokenizer st = new StringTokenizer(out, "\n");
int i = 0;
if (f.equals(cerchi)) {
c = new Cerchio[st.countTokens()];
while (st.hasMoreElements()) {
c[i] = new Cerchio((String)st.nextElement());
i++;
}
}
else {
p = new Punto[st.countTokens()];
while (st.hasMoreElements()) {
p[i] = new Punto((String)st.nextElement());
i++;
}
}
}
catch (Exception e) {
System.out.println(e.toString());
}
}

public demo(String fc, String fp) {
cerchi = new File(fc);
punti = new File(fp);
carica (cerchi);
carica (punti);
for (int i = 0; i < p.length; i++) {
for (int j = 0; j < c.length; j++) {
System.out.print("Il punto "+i+" di coordinate ("+p[i].getX()+"; "+p[i].getY()+") ");
System.out.print((isInternal(p[i],c[j]) ? "è " : "non è "));
System.out.println("interno alla Circonferenza "+j+" di centro C: ("+c[j].getX()+"; "+ c[j].getY()+") e raggio "+c[j].getRadius());
}
}
}

private double distance(Punto a, Punto b) {
return Math.sqrt((a.getX()-b.getX())*(a.getX()-b.getX())+(a.getY()-b.getY())*(a.getY()-b.getY()));
}

private boolean isInternal(Punto a, Cerchio b) {
return (distance(a, b.getCenter()) <= b.getRadius());
}

public static void main (String[] args) {
demo d = new demo("cerchi.txt", "punti.txt");
}
}

Neds
24-06-2005, 20:59
avevo già in mente di buttare il mio e rifare il prog da capo
ho preso la strada sbagliata (vedi risultato qui sotto :rollo: )
meglio farlo più suddiviso come hai detto tu (Andrea 1979) così posso manipolarlo moooolto meglio
OK grazie mille

PS: mi vergogno pure a far vedere il progetto semi finito(funzionante), però eccovelo lo stesso (non so se :cry: o :maLOL: )
:ciauz:



import java.io.*;

public class Cluster {
public static void main(String args[])
{
try{

// preparo i file cluster e output
FileReader inputcluster = new FileReader("cluster.txt");
BufferedReader cluster = new BufferedReader(inputcluster);

FileWriter fileOutput = new FileWriter("output.txt");
PrintWriter output = new PrintWriter(fileOutput);

//cicla tra i vari punti(cluster)
for(int count2 = 0; count2 < 1000; count2++){

//apre il flusso ad ogni punto per evitare il difetto di continuazione
FileReader inputcerchi = new FileReader("cerchi.txt");
BufferedReader cerchi = new BufferedReader(inputcerchi);

//dichiaro il minimo e la stringa per trovare il cerchio con
//centro più vicino al punto
double rMinimo = 100;
String rMinimoS = "";

// lettura della riga da cluster.txt
String cPunto = cluster.readLine();

//se la riga è piena (non è nulla)
if(cPunto != null){

//taglia la stringa in 2(le coordinate)
String[] coordinataP = cPunto.split("\\s");

//converto in double le due substringhe e trovo le coordinate
double xPunto = Double.parseDouble(coordinataP[0]);
double yPunto = Double.parseDouble(coordinataP[1]);

//preparo l'output del cluster
output.println("Cluster (" + xPunto + " " + yPunto + "): ");

//output in console
System.out.println("Cluster (" + xPunto + " " + yPunto + "):");

//cicla tra i vari cerchi
for(int count = 0; count < 1000; count++){

//lettura della riga da cerchi.txt
String cCerchio = cerchi.readLine();

// se la riga è piena (non è nulla)
if(cCerchio != null){

//taglia la stringa in 3 subStringhe
String[] coordinataC = cCerchio.split("\\s");

// conversione in double delle coordinate e del raggio
double xCerchio = Double.parseDouble(coordinataC[0]);
double yCerchio = Double.parseDouble(coordinataC[1]);
double rCerchio = Double.parseDouble(coordinataC[2]);

// verifica se il cerchio contiene il punto
// calcolando la distanza tra il centro del cerchio e il punto
//richiamando il metodo pitagora
double distanza = pitagora(xPunto, yPunto, xCerchio, yCerchio);

//se la distanza è minore del raggio
//cioè se il punto è contenuto
if (distanza <= rCerchio){
//stampa le coordinate del cerchio
output.println(xCerchio + " , " + yCerchio + " raggio: " + rCerchio);
//calcolo per trovare il cerchio con il centro più vicino al punto
if (rCerchio <= rMinimo){
rMinimo = rCerchio;
rMinimoS = (xCerchio + " " + yCerchio);
}
}
}
//se la riga è nulla, incrementa il count di 2000
//per interrompere il ciclo
else
count += 2000;
}
//stampa linea vuota per ordinare l'output
output.println("");
//stampa il cerchio con il centro più vicino al punto
System.out.println(rMinimoS + " : " + rMinimo + "\n");
}
//se la riga è nulla, incrementa il count2 di 2000
//per interrompere il ciclo
else
count2 += 2000;
//chiusura del file cerchi.txt
cerchi.close();
}
//chiusura dei file output e cluster.txt
output.close();
cluster.close();

}//gestore delle eccezioni
catch (IOException e){
System.out.println("Errore: " + e);}
}

//metodo pitagora che calcola la distanza tra due punti
public static double pitagora(double xPunto, double yPunto, double xCerchio, double yCerchio)
{
return (Math.sqrt(((xPunto - xCerchio) * (xPunto - xCerchio)) + ((yPunto - yCerchio) * (yPunto - yCerchio))));
}
}

Loading