Arbeitsfeld in gleich große Bereiche einteilen

[schmatti]

Hallöchen liebe Java-Gemeinde.
Im Rahmen meines Studiums muss ich eine Aufgabe mittels Java lösen. Folgend: Eine Drohne soll in einem definierten Arbeitsfeld verschiedene Koordinaten anfliegen und zum Ende soll meine Porgramm die zurückgelegte Strecke, als auch die Anzahl der "Wandüberquerungen" wiedergeben. Den Gesamtbereich und die Koordinaten lese ich aus einer Datei ein.
Und nun zu meinem Problem, die "Wandüberquerungen": Am Anfang des Programmes soll abgefragt werden, wie viele Wände in dem Arbeitsfeld stehen, also in wie viele gleich große Bereiche das Feld aufgeteilt werden soll. Soweit so gut. Aber wie genau lege ich die Wände bzw. die entstandenen Bereiche am logischten fest, sodass ich im nachhinein ganz einfach mit einer Methode die Wandüberquerungen, als auch die zurückgelegte Strecke aufsummieren kann ?
Ich steh schon seid mehreren Tagen auf dem Schlauch und hoffe, dass diese Frage nicht ein zu großes Fass aufmacht.

SO mein Erzeugnis bis hier hin:

    public static void main(String[] args)
    {
        try {
            FileInput leser = new FileInput ("C:/Users/eclipse-workspace/Koordinaten.txt");
            
            String zeile = leser.leseZeile();
            
            String[] spalte = zeile.split (";");
            
            //Hier wird die erste Zeile jeweils von String in einen Wert umgewandelt
            double xAbsolut = Integer.parseInt (spalte[0]);
            double yAbsolut = Integer.parseInt(spalte[1]);
            
            //Nebenrechnungen um den Arbeitsbereich zu definieren
            double xNegativ = 0. - ( xAbsolut / 2 );
            double yNegativ = 0. - ( yAbsolut / 2 );
            double xPositiv = 0. + ( xAbsolut / 2 );
            double yPositiv = 0. + ( yAbsolut / 2 );
            
            int anzahlMauer = 0;
            
            //Anzahl der Mauern abfragen / Wiederholen bei falscher Eingabe
            while (true)
            {
                //Keine Zeichen / Buchstaben
                try
                {
                    anzahlMauer = IO.readInt("Bitte eine POSITIVE GANZE Zahl als Anzahl der Mauern eingeben: ");
                    //Keine negativen Zahlen
                    if (anzahlMauer > 0)
                    {
                        break;
                    }
                    else
                    {
                        IO.println("Bitte keine negativen Werte");
                    }
                }
                catch (InputMismatchException fehler)
                {
                    IO.println("Fehler! Das war eine fehlerhafte Eingabe! ");
                }
            }
            
            //Hier wird der Arbeitsbereich in die einzelnen Breiche definiert
             //int anzahlBereiche = anzahlMauer + 1;
            
            
             //                            //
             // Hier bitte noch ergänzen//
             //                            //
            
            
            while ((zeile = leser.leseZeile()) != null)
            {
                leser.leseZeile();
            }
            
            leser.schliesseDatei ();
        }
        catch (IOException e)
        {
            IO.println("Fehler beim lesen der Datei! " + e.getLocalizedMessage());
            System.exit(1);
        }
    }

}

Ich danke schonmal für eure Beihilfe.
Gruß schmatti

 

[LimDul]

Nun, die Bereiche sollen gleich groß sein. Ergo, wenn du eine Breite von 100 Metern hast und eine Wand, dann steht bei 50 Metern.
Hast du 9 Wände stehen die bei 10,20,30,40,50,60,70,80,90 Metern.

Einfache eine Strecke in AnzahlWände + 1 gleich große Strecken aufteilen,

 

[Times]

d

Hi.
Bin mir nicht sicher ob ich die Frage korrekt verstanden habe, aber ich versuche es mal wiederzugeben:
Bitte korrigieren wenn falsch!

Du hast ein großes Feld welches von einer Drohne abgeflogen werden soll. Dieses Feld ist in gleichgroße
Bereiche aufgeteilt werden sodass du anhand des Flugweges der Drohne u.a. die Dauer in einzelnen Bereichen bestimmen kannst als auch die Bereichswechsel dokumentieren kannst.

Was im folgendem noch nicht eingearbeitet / bekannt ist, ist die Umrechnung der reelen Koordinaten in virtuelle Koordinaten die in einfache Bereiche aufgeteilt sind!!

Ich nenne die Gesamt-Fläche mal "Map" und einen einzelnen Bereich "Chunk".
Für die Map würde ich eine Klasse anlegen und für den Chunk auch eine eigene Klasse.
Die Klasse Map hat ein 2-Dimensionales Array mit Chunks.

Nehmen wir an die Map ist 10000m² (100x100) groß und ein Chunk auf 10x10 Meter, also 100m² eingeteilt, dann hast du 100 Chunks in deiner Map.

Chunk[][] chunks = new Chunk[10][10];

Diese initialisiert du dann einfach entsprechend mit den Karten-Daten. Im Chunk solltest du festhalten:
Chunk-Positionen X,Y (Bezogen auf das Chunk-Array). Hier solltest du so vorgehen, das du später die Grid-Koordinaten anhand der tatsächlichen Koordinate berechnen kannst:

Koordinate: 43.6 ; 72.1
Chunk ermitteln:
int gridX = 43.6 / 10 = 4 (Floor!).
int gridy = 72.1 / 10 = 7 (Floor!).

Chunk c = chunks[gridX][gridy]

Nun musst du deiner Map Klasse noch eine "Processing" Methode hinzufügen um die Flugstrecke einzuarbeiten um dann die Chunkwechsel nach eigenem belieben zu ermitteln.. zb:

int chunkChanges = 0;
Chunk lastChunk = null;
processFlyingRoute(Point p){
    
    Chunk activeChunk = chunks[p.x / 10][p.y / 10];
    if (activeChunk != null){
        if (lastChunk != null){
            if (activeChunk != lastChunk){
                chunkChanges++;
            }
        }
    }
    lastChunk = activeChunk;

}

Hoffe ich konnte dir damit weiterhelfen!