Koordinatensystem in C programmieren!(Hilfe)



  • Hallo,

    ich wollte mal fragen, on jemand schon einmal ein Koordinatensystem in C geschrieben hat ? Bin nämlich gerade dabei eine Kurvendiskussion zu schreiben, wo dann einzelne Werte im Koordinatensystem angezeigt werden, aber soweit bin ich ja noch nicht. Müsste erstmal wissen wie ich genau das Koordinatensystem zeichen bzw. programmiere. Hat jemand ein Beispiel wo es fertig ist? Das würde mir sehr helfen.

    Vielen Dank schon einmal im voraus!

    cYaaa cASh



  • Ist jetzt dein Problem das setzen der Pixel oder die Berechnung selbst?



  • hab sowas schon mal gemacht, der code is allerdings etwas umfangreicher, weil das koordinatensystem beliebig skalierbar ist und der poit of view (mittelpunt) frei waelbar (normalerweise ist 0/0 in der mitte des sichtfeldes)

    wennst interesse dran hast, sags, dann post ichs dir



  • Korbinian schrieb:

    hab sowas schon mal gemacht, der code is allerdings etwas umfangreicher, weil das koordinatensystem beliebig skalierbar ist und der poit of view (mittelpunt) frei waelbar (normalerweise ist 0/0 in der mitte des sichtfeldes)

    wennst interesse dran hast, sags, dann post ichs dir

    Hi,
    würde mich auch mal interessieren! Wen du's nicht hier posten willst schicks mir mal bitte per Mail: sulfrian @ gmx.net

    MfG

    Alexander Sulfrian



  • Hi @ all

    @ Korbinian:
    Ich hätte auch Interesse daran. Ich muss verschiedene Chartarten darstellen, was mir bisher nicht gelungen ist.

    Wenn es möglich ist, könntest du es auch mir zuschicken ? mrgoochie@web.de

    Thx



  • soso, dann kram ich das mal raus 🙂 is allerdings etwas wirr, weil das nur fragmente einer vcl komponente sind

    //---------------------------------------------------------------------------
    void FGraphBox::Write2Canvas(TCanvas *Canvas, int Height, int Width, bool fkt)
    {
        /*  Es wird zuerst überprüft, ob noch gezeichnet wird, oder eine ungültige
            Canvas übergeben wurde. In beiden Fällen wird abgebrochen.            */
        if (m_painting)
        {
            ShowMessage("Berechnungen und Zeichnung noch nicht abgeschlossen");
            return;
        }
        if (Canvas == NULL)
        {
            ShowMessage("Noch keine Canvas eingestellt!");
            return;
        }
        // Alle für's Zeichen wichtigen Daten vorhanden
        // Wir müssen verhindern, dass die Methode überschneidend aufgerufen wird
        m_painting = true;
        //-----------------------------------------------------------------------
        /*  Zeichnen des Koordinatensystems:
            - ein weisses Rechteck
            - hellgraues Raster mit Schrittweite den Maßstäben ensprechend
            - Koordinatenachsen                                                   */
        Canvas->Pen->Color = clWhite;
        Canvas->Brush->Color = clWhite;
        Canvas->Rectangle(0, 0, Width, Height);
        Canvas->Pen->Color = clSilver;
        for (int y = Height/2 + m_viewpointy*m_scaley; y > 0; y -= m_scaley)
        {
            Canvas->MoveTo(0, y);
            Canvas->LineTo(Width, y);
        }
        for (int y = Height/2 + m_viewpointy*m_scaley; y < Height; y += m_scaley)
        {
            Canvas->MoveTo(0, y);
            Canvas->LineTo(Width, y);
        }
        for (int x = Width/2 - m_viewpointx*m_scalex; x > 0; x -= m_scalex)
        {
            Canvas->MoveTo(x, 0);
            Canvas->LineTo(x, Height);
        }
        for (int x = Width/2 - m_viewpointx*m_scalex; x < Width; x += m_scalex)
        {
            Canvas->MoveTo(x, 0);
            Canvas->LineTo(x, Height);
        }
        Canvas->Pen->Color = clBlack;
        Canvas->MoveTo(0, Height/2 + m_viewpointy*m_scaley);
        Canvas->LineTo(Width, Height/2 + m_viewpointy*m_scaley);
        Canvas->MoveTo(Width/2 - m_viewpointx*m_scalex, 0);
        Canvas->LineTo(Width/2 - m_viewpointx*m_scalex, Height);
        //-----------------------------------------------------------------------
        /*  Um die Funktionen nach dem Zeichnen noch auseinanderhalten zu können
            werden zum Zeichnen unterschiedliche Farben benutzt. Dazu bietet sich
            die Funktion StringToColor aus der VLC an. Sie wandelt die untenstehen-
            den Farbnamen in TColor Objekte um, die wiederum der Eigenschaft "Color"
            von Canvas->Pen übergeben zugeordnet werden können.                   */
        char *colors[] = { "clBlue", "clFuchsia", "clLime", "clRed", "clNavy",
                            "clOlive", "clPurple", "clTeal", "clYellow" };
        int col_index = 0;
        Canvas->Font->Size = 12;
        Canvas->Font->Name = "Veranda";
        // Wenn eine Definitionsüberschreitung stattfand, wird nicht gezeichnet!
        bool fehler;
        int text_y = 10;
        Canvas->MoveTo(0,0);
        /*  Die Funktionsliste wird komplett durchgegangen, und jede einzelne Funk-
            tion wird gezeichnet. Dazu wird zuerst die Farbe angepasst. Zuerst wird,
            falls das fkt Flag true ist, der Funktionsname ausgegeben.            */
        for (FuncList::iterator iter = m_functions.begin();
                iter != m_functions.end(); iter++)
        {
            Canvas->Font->Color = StringToColor(colors[col_index]);
            Canvas->Pen->Color = StringToColor(colors[col_index++]);
            if (fkt)
            {
                std::string text = "f(x) = ";
                text += iter->echofunction();
                Canvas->TextOut(10, text_y, text.c_str());
                text_y += 20;
            }
            /*  Für die Berechnung wird zunächst der X Wert benötigt. Dieser wird
                dadurch berechnet, in dem man aus dem absoluten X Wert (von 0 bis
                Breite der Canvas) den relativen X Wert für das Koordinatensystem,
                das auf unseren Maßstab einstellt ist, zuordnet.                  */
            double werte[] = { ((double)(1 - Width / 2) / (double)m_scalex
                                + (double)m_viewpointx) };
            /*  Der absolute Y Wert in der Canvas wird wiederum durch ein Addieren
                des Y Wertes des Betrachterpunktes und anschliessendes multiplizie-
                ren mit dem Y Maßstab errechnet.                                  */
            try
            {
                Canvas->MoveTo(0, (double)Height/2
                            - iter->calculate(werte, fehler)*(double)m_scaley
                            + (double)(m_viewpointy*m_scaley));
            }
            catch (...) {}
            /*  Jetzt nachdem der Startpunkt zum Zeichnen berechnet ist, wird
                Schritt für Schritt zu jedem X Wert der Canvas ein Y Wert berechnet,
                und anschliessend eingezeichnet.                                  */
            for (int x = 1; x < Width; x++)
            {
                werte[0] = (double)(x - Width / 2) / (double)m_scalex
                            + (double)m_viewpointx;
                try
                {
                    double ywert = iter->calculate(werte, fehler);
                    double abs_ywert = (double)Height/2 - ywert*(double)m_scaley
                                    + (double)(m_viewpointy*m_scaley);
                    if (fehler)
                        Canvas->MoveTo(x, abs_ywert);
                    else
                        Canvas->LineTo(x, abs_ywert);
                }
                catch (...) {}
            }
            if (col_index > 8)  col_index = 0;
        }
        m_painting = false;
        return;
    }
    

    das is scho n jahr her. mal schauen ob ichs noch hinkrieg: FGraphbox ist von TPaintbox abgeleitet, und hat damit eine Canvas (wo das alles reingepinselt wird).
    erstmal ein par variablen, die klassenweit sind: m_viewpointx m_viewpointy (Der mittelpunkt des sichtfeldes), m_scalex (maßstab x achse), m_scaley (maßstab y achse). die Canvasbefehle LineTo und MoveTo sollten klar sein.

    die vorgehensweise is jetz so, dass erst das koordinatensystem gepinselt wird, und dann die funktionen, indem zu jedem x ein y geholt wird. hierbei muss halt das "lokale" canvas-x umgerechnet werden in ein "richtiges" x fuer die funkionen. wie das geht steht hoffentlich in den kommentaren 😃
    viel spass damit. falls unklarheiten bitte fragen, dann schau ichs mir nochmal an



  • Hi,
    danke erstmal! Was für'n Typ ist'n m_function? vector? list?

    MfG

    Alexander Sulfrian



  • glaub es war n vector, aber is ja wurscht, das sind nur die menge der funktionen die gezeichnet werden. eine funktion hat (u.a.) die memberfunktion calc, damit wird halt der y wert zu gegebenen x ausgerechnet. is n double array, weil man theoretisch mehrerere variablen anbegben kann


Anmelden zum Antworten