Alle Kombinationen aus zwei Arrays

[Thomas21]

Hallo,
Ich bräuchte mal wieder eure Hilfe
Wir müssen mithilfe einer vorgegebenen Methode Helligkeitswerte für verschiedene Farben eines Fotos ermitteln.
Dazu müssen wir jeden einzelnen Pixel durch so einen Befehl laufen lassen:
int rot = pixel.Anteilrot (10,20);
Die beiden Zahlen in den Klammern sind also Koordinaten des Bildes.

Ebenfalls können wir mit dieser Methode die Anzahl der Pixel in Breite und Höhe auslesen.

An diesem Punkt komme ich nicht weiter.

Ich muss irgendwie alle Kombinationen aus den Pixeln in der Höhe und den Pixeln in der Breite berechen.
Meine Überlegung ist, eine if-Abfrage für die Breite laufen zu lassen und den Wert für die Höhe jedesmal um 1 zu erhöhen wenn die gesamte Breite durchlaufen wurde.
Ich hoffe das ist einigermaßen verständlich erklärt
jedoch bekomme ich hier "java.lang.ArrayIndexOutOfBoundsException" wenn die Pixel für die Breite durchgelaufen sind. (nehme ich an)
Ich habe die Höhe und die Breite jeweils in ein Array gepackt in der Hoffnung damit besser rechnen zu können.

    for(int q=0, p=0, r=0; r<Abreite.length; r++)
            {
                IO.println(r);
                if ( r>=Abreite.length && p<=Ahoehe.length)
                {
                    int rot = pixel.Anteilrot (Abreite[r],Ahoehe[p]);      
                    IO.println(rot);
                    IO.println(p);
                    p++;
                }
              
            }

Hat vielleicht jemand eine Idee?

 

[JCODA]

if-Schleifen gibt es nicht. If-Abfragen und For-Schleifen gibt es aber

Benutze zwei verschachtelte For-Schleife, eine für Breite, eine für Höhe.

 

[Thomas21]

ist korrigiert
vielen Dank das probier ich gleich mal aus

 

[Thomas21]

Ich habe eine for-Schleifen-Konstruktion gebastelt, allerdings bekomme ich am Ende zu kleine Werte heraus.

int y=0;
                       
                        for(int r=0; r<breite;r++)
                        {
                            for(int p=0; p<hoehe; p++)
                            {
                                int rot = pixel.Anteilrot (r,p);
                                int gruen = pixel.Anteigruenl (r,p);
                                int blau = pixel.Anteilblau (r,p);
                                HWerter[y] = rot;
                                HWerteg[y] = gruen;
                                HWerteb[y] = blau;
                                y++;
                            }
                           
                        }

ich wollte jeweils für jede Farbe ein Array befüllen. Allerdings bin ich mir nicht sicher welche Variable ich zum "durchlaufen" der Arrays benutzen soll.
Die Variable p wird doch bei jedem Durchlauf wieder auf 0 gesetzt oder?

 

[JCODA]

Bisher sieht dein Code ganz gut aus, möglicherweiße bietet sich r+p*breite oder r*hoehe+p an. Kommt drauf an, in welcher Reihenfolge, du die werte Abspeichern möchtest.
Was meinst du damit, dass du zu kleine Werte bekommst?

 

[Thomas21]

Das Ergebnis was zum Schluss rauskommen soll ist vorgegeben.
Die Schleifen sind nur ein Teil der Aufgabe. Ich glaube aber das hier der Fehler liegt.


Ich verstehe gerade nich was ich mit "r+p*breite" oder "r*hoehe+p" machen kann. Die Reihenfolge in der die Werte in die jeweiligen Arrays gespeichert werden ist egal.

 

[JCODA]

Oh ja, ich hab nicht gesagt, dass ich meinte, dass sich diese Werte als Index eigenen. Ich meinte es etwa so:

                        for(int r=0; r<breite;r++){
                            for(int p=0; p<hoehe; p++){                              
                                HWerter[r*hoehe+p] = pixel.Anteilrot (r,p);
                                HWerteg[r*hoehe+p] = pixel.Anteilgruen (r,p);
                                HWerteb[r*hoehe+p] = pixel.Anteilblau (r,p);                                
                            }                          
                        }

Ansonsten kann ich dir leider nicht weiterhelfen, ich denke das ist letztlich äquivalent zu dem, was du bereits hast.
Du kannst ja mal mehr von der Aufgabe preisgeben, und genau sagen, was du erwartest und welcher Wert tatsächlich raus kommt.

 

[Thomas21]

Die Ergebnisse sind ungefähr halb so groß wie sie sein müssten.
Rot: 90; Grün: 106 und Blau: 130

und diese Werte bekomme ich raus:
Rot: 35; Grün: 47; Blau: 68
Das ist der ganze Code

public class Main {
    public static void main(String[] args) {
        try {
            String pixelDateiName = "Foto.jpg";
            Pixel pixel = new Pixel (pixelDateiName);
            int hoehe = pixel.hoehe();
            int breite = pixel.breite();
            int PixelGes = hoehe * breite;
            System.out.println("Pixelzahl insgesamt " + PixelGes);
            System.out.println(breite);
            System.out.println(hoehe);
          
          
          

          
          
            /*Arrays testen
            for(int z = 0; z<Abreite.length; z++) {
            System.out.println(Abreite[z]);
             }*/
      
                  
                      
                        int[] HWerter = new int[PixelGes];
                        int[] HWerteg = new int[PixelGes];
                        int[] HWerteb = new int[PixelGes];
                  
                      
              
                        for(int r=0; r<breite;r++){
                            for(int p=0; p<hoehe; p++){                           
                                HWerter[r+p*breite] = pixel.Anteilrot (r,p);
                                HWerteg[r+p*breite] = pixel.Anteilgruen (r,p);
                                HWerteb[r+p*breite] = pixel.Anteilblau (r,p);
                              
                            }         
                          
                        } 
      
    //Addierte Werte ausgeben und durch gesamte pixel teilen
                      
    Addieren (HWerter);
    System.out.println(Addieren (HWerter));
    int Drot = Addieren (HWerter)/PixelGes;
  
  
    Addieren (HWerteg);
    int Dgruen = Addieren (HWerteg)/PixelGes;
  
    Addieren (HWerteb);
    int Dblau = Addieren (HWerteb)/PixelGes; 
          
   System.out.println("Durchschnittliche Helligkeit--> " + "Rot: " + Drot + ", " + "Grün: " + Dgruen + ", " + "Blau: " + Dblau);       
  
        }
        catch (IOException e) {
            System.out.println("Fehler beim Einlesen der Datei!");
            e.printStackTrace();
        }

      
    }

    private static int Addieren(int[] hWerte) {
      

    //Helligkeitswerte addieren
        int AktuelleZahl =0;
        int k=0;
        int i=0;
        int[] MaxWert = new int[999999];
        while (k < 999999)
        {
            AktuelleZahl= AktuelleZahl + hWerte[i];
            MaxWert[i]= AktuelleZahl;
            i++;
            k++;
        }
      
        int max = 0; //größte Zahl
        for(int t = 0; t < MaxWert.length; t++) {
           if(MaxWert[t] > max) {
              max = MaxWert[t];
           }
        }
      
  
        //Aktuelle Zahl (Addierte Helligkeitswerte) als Rückgabewert wieder ausgeben
        return max;
}

  
    }

 

[JCODA]

uhh, deine Addieren-methode ist sehr umständlich.
Wie wäre es mit einer einzigen For-Schleife, die die Summe berechnet?
Ohne maximum und so?
und du rufst diese Addieren methode jeweils einmal zu oft auf. (Ist unnötig und bringt nichts.)
Ansonsten kannst du dir ja mal die einzelnen Farb-Arrays ausgeben lassen, und schauen, ob da tatsächlich das drinsteht, was du erwartest.