3. Durch 8 teilen geht nicht?! bin ich zu doof?

Durch 8 teilen geht nicht?! bin ich zu doof?

  • W

    Hi,

    ich verzweifeln mal wieder mit C++. Also mein Problem ist einfach das ich eine Zahl nicht durch acht (oder irgendeine andere zahl) teilen kann. also ich programmiere schon etwa 12 jahre und hab nach turbo pascal , delphi und visual basic eine ungefähre ahnung davon wie ein computer ein programm abarbeitet, ich denke mal mein problem liegt an der typenkonversation, aber nicht mal bei TP hat ich da so große Probleme.

    Aaalso, was will ich eigentlich? ich wollte etwas c++ lernen ohne gleich mit windows-api zu handtieren oder endlose "zahl eins durch zahl zwei ist gleich"-konsolenanwendungen zu schreiben, also dachte ich mir wie wärs mit einem Renderer der das ergebnis in eine bmp datei speichert. das klappt alles bestens. so nun wollte ich mir eine Funktionen schreiben die mir den bildspeicher interpoliert (pixel=durchschnitt der nachtbarpixel), aber bei der division geht alles schief und ich weiss echt nicht mehr was ich probieren soll. ok, hier erstma etwas code:

    der bildspeicher(ich hab char gewählt, da es genau ein byte groß is)

    struct COLOR{
    char b;
    char g;
    char r;
} ScrBuf[SCREENW][SCREENH];

    und nun die funktion die eigentlich interpolieren soll (rf,gf und bf sind fast immer 0)

    int GRAPHICS2D::BlurPixel(int x,int y)
{
    int rr=0;
    int gg=0;
    int bb=0;
    float rf;
    float gf;
    float bf;
    rr= ScrBuf[x][y].r*4;
    rr+= ScrBuf[x+1][y].r;
    rr+= ScrBuf[x-1][y].r;
    rr+= ScrBuf[x][y+1].r;
    rr+= ScrBuf[x][y-1].r;
    gg= ScrBuf[x][y].g*4;
    gg+= ScrBuf[x+1][y].g;
    gg+= ScrBuf[x-1][y].g;
    gg+= ScrBuf[x][y+1].g;
    gg+= ScrBuf[x][y-1].g;
    bb= ScrBuf[x][y].b*4;
    bb+= ScrBuf[x+1][y].b;
    bb+= ScrBuf[x-1][y].b;
    bb+= ScrBuf[x][y+1].b;
    bb+= ScrBuf[x][y-1].b;
    rf=float(rr)*float(0.125f);
    gf=float(gg)*float(0.125f);
    bf=float(bb)*float(0.125f);
    ScrBuf[x][y].r=rf;
    ScrBuf[x][y].g=gf;
    ScrBuf[x][y].b=bf;
    return 0;
}

    was mach ich falsch?!
    PS:round geht auch nicht und ich schreibe mit GNU C++ Compiler in Code::Blocks 1.0

    Mfg Weltraumputze

    0
  • P

    Gib dir doch die rr, gg, bb Werte mal aus, was kommt da raus?

    Was machst du eigentlich an Rändern, wo man nicht nach links,rechts oben oder unten schauen kann?

    Und für eine Color würde ich eher unsigned char nehmen. Sonst kann nach 127 Schluss sein.

    0
  • F

    Vermutlich läßt du die Funktion über sämtliche Pixel in einer Schleife laufen, oder?
    Dabei hast du das gewaltige Problem das schon der zweite Aufruf nicht mehr auf den Originaldaten rechnet, sondern schon teilweise auf den interpolierten. Du musst einen zweiten Speicher erstellen und diesen füllen.

    0
  • W

    also, rr, rg, rb sind fast immer null (nicht NULL) oder kleiner als 10. ich schreibe übrigens einen RENDERER d.h. in diesem beispiel einen bildspeicher mit 2D-Graphiken füllen und dann effekte hinzufügen. das die schleife durch die nachtbarberechnung eigentlich ungeeignet ist, ist mir schon klar, aber das stört nur minimal (hab die selbe schleife mal in TP geschrieben) und dann hab ich zwei arrays die ich nicht überblicken kann, außerdem funtioniert das genauso wenig...

    das mit unsigned char probier ich gleich mal aus...

    0
  • W

    ps: ich hab auch mal versucht nur die farbwerte zu halbieren/dritteln , also abzudunkel, das ergibt auch fast immer 0!

    0
  • W

    ok, unsigned char war das problem... danke^^

    0
  • *

    Mal noch eine Frage:

    float rf;
    float gf;
    float bf;

    Am Anfang(!)

    rf=float(rr)*float(0.125f);
    gf=float(gg)*float(0.125f);
    bf=float(bb)*float(0.125f);
    ScrBuf[x][y].r=rf;
    ScrBuf[x][y].g=gf;
    ScrBuf[x][y].b=bf;

    In der Mitte (?!).
    => Warum castest du einene float (0.125f) in einen float?
    => Warum legst du überhaupt eine Temporäre Variable an?
    => Warum legst du diese schon am Funktionsanfang an?

    struct color_t
{
    unsigned char red;
    unsigned char green;
    unsigned char blue;

    color_t()
        : red(0), green(0), blue(0)
    {}
} 

class graphics2d
{
    std::vector<std::vector<color_t>> m_screenbuffer;

public:
    graphics2d(const std::size_t width, const std::size_t height)
        : m_screenbuffer(width, std::vector<color_t>(height))
    {}

public:
    void blur_pixel(const std::size_t, const std::size_t);
};

void graphics2d::blur_pixel(const std::size_t x, const std::size_t y)
{
    if (m_screenbuffer.size() <= x || m_screenbuffer[0].size() <= y) throw std::out_of_range("invalid pixel position");

    unsigned int red(m_screenbuffer[x][y].red * 4);
    red += m_screenbuffer[x + 1][y].red;
    red += m_screenbuffer[x - 1][y].red;
    red += m_screenbuffer[x][y + 1].red;
    red += m_screenbuffer[x][y - 1].red;

    unsigned int green(m_screenbuffer[x][y].green * 4);
    green += m_screenbuffer[x + 1][y].green;
    green += m_screenbuffer[x - 1][y].green;
    green += m_screenbuffer[x][y + 1].green;
    green += m_screenbuffer[x][y - 1].green;

    unsigned int blue(m_screenbuffer[x][y].blue * 4);
    blue += m_screenbuffer[x + 1][y].blue;
    blue += m_screenbuffer[x - 1][y].blue;
    blue += m_screenbuffer[x][y + 1].blue;
    blue += m_screenbuffer[x][y - 1].blue;

    m_screenbuffer[x][y].red = static_cast<float>(red) * 0.125f;
    m_screenbuffer[x][y].green = static_cast<float>(green) * 0.125f;
    m_screenbuffer[x][y].blue = static_cast<float>(blue) * 0.125f;
}

    Beachte bitte, dass das einen Fehler bei x = 0 || y == 0 ergibt! (und wenn x > screen_width || y > screen_height)

    0
Anmelden zum Antworten