Alle Kombinationen aus zwei Arrays

Diskutiere Alle Kombinationen aus zwei Arrays im Allgemeine Java-Themen Forum; Hallo, Ich bräuchte mal wieder eure Hilfe :( Wir müssen mithilfe einer vorgegebenen Methode Helligkeitswerte für verschiedene Farben eines Fotos...

  1. Thomas21
    Thomas21 Neues Mitglied
    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:D
    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.

    Code (Java):
        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?
     
  2. Vielleicht hilft dir dieser Kurs hier weiter --> (hier klicken)
  3. JCODA
    JCODA Aktives Mitglied
    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.
     
    VfL_Freak gefällt das.
  4. Thomas21
    Thomas21 Neues Mitglied
    ist korrigiert:)
    vielen Dank das probier ich gleich mal aus
     
  5. Thomas21
    Thomas21 Neues Mitglied
    Ich habe eine for-Schleifen-Konstruktion gebastelt, allerdings bekomme ich am Ende zu kleine Werte heraus.
    Code (Java):
    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?o_O
     
  6. JCODA
    JCODA Aktives Mitglied
    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?
     
  7. Thomas21
    Thomas21 Neues Mitglied
    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.
     
  8. JCODA
    JCODA Aktives Mitglied
    Oh ja, ich hab nicht gesagt, dass ich meinte, dass sich diese Werte als Index eigenen. Ich meinte es etwa so:
    Code (Java):

                            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.
     
  9. Thomas21
    Thomas21 Neues Mitglied
    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
    Code (Java):

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

     
        }


     
     

     


     
     
  10. JCODA
    JCODA Aktives Mitglied
    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.
     
Die Seite wird geladen...

Alle Kombinationen aus zwei Arrays - Ähnliche Themen

Alle Zahlenkombinationen aus 9 zahlen finden
Alle Zahlenkombinationen aus 9 zahlen finden im Forum Java Basics - Anfänger-Themen
Alle möglichen Kombinationen in einem Array ausgeben
Alle möglichen Kombinationen in einem Array ausgeben im Forum Java Basics - Anfänger-Themen
Java Spintax: Alle Kombinationen Erzeugen
Java Spintax: Alle Kombinationen Erzeugen im Forum Allgemeine Java-Themen
Alle Kombinationen aus 2 Karten berechnen
Alle Kombinationen aus 2 Karten berechnen im Forum Allgemeine Java-Themen
Alle Kombinationen aus Listenelementen, Anzahl Listen unterschiedlich
Alle Kombinationen aus Listenelementen, Anzahl Listen unterschiedlich im Forum Java Basics - Anfänger-Themen
Thema: Alle Kombinationen aus zwei Arrays