3. Array

Array

  • B

    Also ich habe da ein Problem mit nem Array:
    Ich durchlaufe da eine Schleife:

    for (WORD y=0; y<hBmpInfo.bmHeight; y++){
        for (WORD x=0; x<hBmpInfo.bmWidth ; x++){
            BYTE jRed   = pPixels[p+2];
            BYTE jGreen = pPixels[p+1];
            BYTE jBlue  = pPixels[p+0];

            // next pixel
            p+=3;
        }
    }

    x und y wir ja jeweils um 1 erhöht. Wenn ich aber die Schrittweite erhöhen will:
    x+=2 oder x+=3 (bei y dann das gleiche), wieviel muss ich dann bei p addieren. Ich raff das irgentwie net. Ist 100% voll einfach, naja 🙄 🙄

    Achja, in dem Array sind die Pixel einer Bitmap (falls das was zur Sache tut)

    cu para
    😃

    0
  • T

    Kannst Du das nochmal genauer erklären??
    ich verstehe nicht was Du möchetest.

    x+=2 oder x+=3 das kommt doch bei Dir im Programm gar nicht vor
    Du meinst wahrscheinlich p+=2 oder p+=3

    Wie groß ist eigentlich hBmpInfo.bmHeight und hBmpInfo.bmWidth

    Was meinst Du mit Schrittweite

    😕 😕 😕

    0
  • B

    nein bei mir kommt x++ und y++ vor. daraus will ich jetzt x+=3 und y+=3 machen. damit ich nur einen drittel des vorherigen bildes habe (das array ist ja ein bitmap, also im array ist ein bitmap).
    Wenn ich das mache stimmt das mit dem p nicht mehr. da p auf irgentwas anderes zeigt. Schrittweite meine ich zum beispiel iSteps=3; und dann x+=iSteps und y+=iSteps. Jetzt muss ich dass irgentwie dem p anpassen. So in der Art p+=(iSteps*3); oder was auch immer.

    cu para
    😃

    PS: Muss jetzt in die Schule - meld mich in 2h nochmal

    0
  • T

    sorry, ich verstehe nicht was Du willst.

    "p zeigt auf irgendwas anderes".

    Soll p ein Zeiger sein oder was?
    Bevor ich net weiß was p ist, kann ich Dir wahrscheinlich nicht helfen.

    hBmpInfo.bmHeight Mit welcher Konstante ist das Initalisiert
    hBmpInfo.bmWidth Mit welcher Konstante ist das Initalisiert

    Ich versuche mal Dein Programm so weit ich es verstehe zu erklären.

    Du hast 2 Schleifen.
    Du kommst, da y (am Anfang wahrscheinlich)kleiner ist als hBmpInfo.bmHeight in die innere Schleife.
    y ist Momentan noch 0.

    Die innere Schleife wird so oft durchlaufen, bis x größer ist als hBmpInfo.bmWidth.
    Ich hoffe Dir ist klar, daß y solange Du dich in der inneren Schleife aufhältst nicht erhöht wird.
    Du erhöhst pro inneren Schleifendurchlauf p um 3 und x um 1.
    Du überschreibst auch immer wieder pro Schleifendurchlauf jRed,jGreen,jBlue aufs Neue. ( Soll das wirklich so sein?? )

    Du bist nun, nachdem x größer geworden ist als hBmpInfo.bmWidth, wieder in der äußeren Schleife die nun erneut durchlaufen wird. y wird um 1 erhöht.
    y ist also nun 1.
    Nun kommst Du wieder in die innere Schleife.
    x ist jetzt wieder auf 0 gesetzt.
    Diese Schleifendurchläufe geht solange weiter bis y größer ist als hBmpInfo.bmHeight.

    Kann erst morgen, wenn ich Zeit habe wieder vorbeischauen.
    Vielleicht Hilft Dir das ja weiter.

    [ Dieser Beitrag wurde am 09.01.2003 um 14:43 Uhr von tho300 editiert. ]

    0
  • B

    Ja also sorry, dass ich mich so schlecht ausgedrückt habe.
    Jetzt nochmal.

    Ich habe in meinem Array ein Bitmap das so aufgebaut ist:
    *** *** *** *** ***
    *** *** *** *** ***
    *** *** *** *** ***

    ein Block (**) ist dabei ein Pixel, die einzelnen Punkte () sind die jeweiligen rot, blau und grün Anteile dieses Pixels.

    In meiner Schleife fange ich links oben in der ersten Zeile an. Ich mache 👍 von oben nach unten und (x) von links nach rechts durch. Also wie wenn man ein Buch liest eben.

    Die Werte für rot, blau, grün werden in Variablen eingelesen und verarbeitet.
    Das verarbeiten habe ich weggelassen zwecks Übersicht.

    Im Normalfall ist es so, dass x und y immer nur um eins erhöht werden.
    Wenn ich aber jetzt zum Beispiel nur jeden 2 Pixel verarbeiten möchte, schreibe ich x+=2 und y+=2. Damit wird praktisch nur jeder 2. Block (***) angesprochen.

    Da im Normalfall p immer dem Blockanfang entspricht, stimmt es nicht mehr überein, wenn ich die "Schrittweite" von 1 (++) auf 2 (+=2) erhöhe, da p, wenn ich bei Schrittweite 2, p+=3 schreibe, noch einem Pixel entspricht, der schon längst verarbeitet wurde, oder normalerweise übersprungen werden sollte.

    Ich hoffe ich habe dass jetzt einigermaßen deutlich erklären können.

    danke!

    0
  • W

    Ich gehe davon aus, dass du nicht wirklich jedes 2te Pixel bearbeiten willst, denn dann wäre das so:

    ||| *** ||| *** |||
*** ||| *** ||| ***

    Dabei bedeutet | "bearbeitet" und * "nicht bearbeitet". Du willst das aber sicher so:

    ||| *** ||| *** |||
||| *** ||| *** |||

    oder? Dann machste das so:

    for(int y=0; y<hBmpInfo.bmHeight; ++y)
{
   p = y * hBmpInfo.bmWidth;
   for(int x=0; x<hBmpInfo.bmWidth ; x++)
   {
      BYTE jRed   = pPixels[p+2];
      BYTE jGreen = pPixels[p+1];
      BYTE jBlue  = pPixels[p+0];

      // next pixel
      p+=6;
   }
}
    0
Anmelden zum Antworten