[Java] lettura coordinate da file di testo

[Neds]

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)


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]

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]

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]

ma devi per forza usare file di tipo testo o era solo un esempio?

[Wave]

mi sono accorto adesso di un errore sul primo post:

la classe è BufferedReader e NON BufferReader....

sorry...

ciao ciao

[Neds]

@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"); >>

[Neds]

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]

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]

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 o :maLOL: )

 
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))));
    }
}