Hilfe bei Plotter und Umrechnung der Koordinaten

[Preddy2005]

Hallo mal wieder! Ich brauche mal Hilfe bei der Programmierung eines Plotters und der Funktion Sin(x).

Ist eine Schulaufgabe... Die Umsetzung mit Delphi bereit mir nicht die Probleme ... Eher die Theorie dahinter... Und ich habe nichts wirklich brauchbares gefunden in Foren und im Internet ... Vielleicht kann mir hier ja jemand helfen... Und unser Lehrer erklärt leider auch kaum was... Deswegen wende ich mich an euch.

Delphi-Quellcode:

var Anzahl_n          :  Integer;
    i, j, k, l, m     :  Integer;
    Schritt           :   Double;
    Y_Max_Wert        : Extended;
    X_Max_Wert        : Extended;
    Y_Min_Wert        : Extended;
    X_Min_Wert        : Extended;
    Y_Max_Min         : Extended;
    X_Max_Min         : Extended;
    Y_Temp_Max        : Extended;
    X_Temp_Max        : Extended;
    Y_Temp_Min        : Extended;
    X_Temp_Min        : Extended;
    Y_Null_Punkt      : Extended;
    X_Null_Punkt      : Extended;

begin

     Y_Max_Wert := 0;
     Y_Min_Wert := 0;
     X_Max_Wert := 0;
     X_Min_Wert := 0;

     Anzahl_n := StrToInt((edtAnzahln.Text));
     Schritt := StrToFloat(edtSchritt.Text);

       { Schritt 1 : Wertetabelle erstellen für die Berechnung
         X aus den Schritten und Y wird aus Sin(x) errechntet }

     for i:= 0 to Anzahl_n do
      begin

       X_Werte_Array[i+1] := X_Werte_Array[i] + Schritt;
       Y_Werte_Array[i+1] := Sin(X_Werte_Array[i]);

       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('Wert von  X : ' + FloatToStr(X_Werte_Array[i]));
       memAusgabe.Lines.Add('Sin   von   X : ' + FloatToStr(Y_Werte_Array[i]));
       memAusgabe.Lines.Add('');

      end;

      // Schritt 2 : Min und Max von Y bestimmen

                // Max Y

       for k:= 0 to Anzahl_n do
        begin

         Y_Temp_Max := Y_Werte_Array[k];
          if (Y_Temp_Max > Y_Max_Wert)
           then Y_Max_Wert := Y_Temp_Max;

        end;

                // Min Y

        for  j := 0 to Anzahl_n do
         begin

          Y_Temp_Min := Y_Werte_Array[j];
           if (Y_Temp_Min < Y_Min_Wert)
            then Y_Min_Wert := Y_Temp_Min;

         end;

                    // Max X

           for l := 0 to Anzahl_n do
            begin
             X_Temp_Max := X_Werte_Array[l];
              if (X_Temp_Max > X_Max_Wert)
               then X_Max_Wert := X_Temp_Max;
             end;

                       // Min X

           for m := 0 to Anzahl_n do
            begin
             X_Temp_Min := X_Werte_Array[m];
              if (X_Temp_Min < X_Min_Wert)
               then X_Min_Wert := X_Temp_Min;
             end;

       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('Y Max-Wert :  ' + FloatToStr(Y_Max_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('Y Min-Wert :  ' + FloatToStr(Y_Min_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('X Min-Wert :  ' + FloatToStr(X_Min_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('X Max-Wert :  ' + FloatToStr(X_Max_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');

       // Schritt 3 : Nullpunktverschiebung durch Subtraktion des Min - Wertes

       Y_Null_Punkt := Y_Min_Wert - Y_Min_Wert;
       X_Null_Punkt := X_Min_Wert - X_Min_Wert;

       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('Y - Nullpunkt nach Verschiebung: ' + FloatToStr(Y_Null_Punkt));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('X - Nullpunkt nach Verschiebung: ' + FloatToStr(X_Null_Punkt));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');

       // Schritt 4 : Max - Min berechnen

       X_Max_Min   := X_Max_Wert - X_Min_Wert;
       Y_Max_Min   := Y_Max_Wert - Y_Min_Wert;
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('X Max/Min Wert: ' + FloatToStr(X_Max_Min));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('Y Max/Min Wert: ' + FloatToStr(Y_Max_Min));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');

       // Schritt 5 : h (bzw. b) (Max - Min) errechnen 

       System_Breite  := imSystem.Width;
       System_Hoehe   := imSystem.Height;

       // Schritt 6 : h - Y Wert



       // Schritt 7 : Runden

       

end;

1.) Ist dieser Ansatz korrekt?

2.) Die Stichpunkte helfen mir nicht von meinem Lehrer. Kann jemand mal erklären wie ich theoretisch weitermachen muss...
Die Theorie dahinter zu verstehen wäre mir wichtiger als der Rest... Mathe ist zumdem schon ein Weilchen her und deshalb
beherrsche ich das alles auch nicht wirklich gut...

Ich hoffe jemand kann mir weiterhelfen.... Danke im voraus für die Mühe und den Aufwand.

[Der_Unwissende]

Hi,
und erstmal herzlich Willkommen in der DP

Ja, leider kann ich dir nicht all zu viel zu deinem Problem sagen. Wird sicherlich auch niemand anderes hier tun. Nicht falsch verstehen, heißt weder dass ich gar nichts sage, es nicht könnte oder Ähnliches! Nur steht in den Regeln der DP drin, dass niemanden die HA gemacht werden und teilweise erinnern deine Formulierungen etwas an eine solche Aufforderung.

So hast du eine sehr allgemeine Frage gestellt und 'ne Menge Code gepostet. Aber natürlich ist dies ein Forum, es gibt Hilfe zur Selbsthilfe und in der DP sicherlich wenig Menschen (oder gar keine?) die nicht helfen.

Also was dein Programm/Problem und die Theorie dahinter angeht, kannst du sagen was genau dein Problem ist? Welche Theoretischen Grundlagen meinst du? Was verstehst du schon, was nicht? Und bitte in kleinen Happen, also wenn du jetzt sagst, du verstehst gar nichts, dann ist das schlecht. Schöner wäre wenn du sagst, ok, das var leitet Variablen ein, is klar. Anzahl_n : Integer heißt es gibt einen Typen der vom Typ Integer ist also Ganzzahlen speichert.
Natürlich musst du nicht alle Typen hier aufzählen oder ähnliches, reicht ja wenn du sagst, ich habe ein Problem mit ... oder ab... weil ich verstehe nicht was .... Noch schöner ist, wenn du da gleich eine Vermutung äusserst, dann wird dir 1000%ig gerne geholfen.

Schon mal vorweg, ein paar Zeilen sind überflüssig. Ich weiß nicht genau wie viel du von dem Programm verstehst oder eben nicht, aber

Delphi-Quellcode:

  Y_Null_Punkt := Y_Min_Wert - Y_Min_Wert; 
  X_Null_Punkt := X_Min_Wert - X_Min_Wert;

Was glaubst du denn was hier gemacht wird? Ich denke mal, du siehst dass es zwei Zuweisungen sind. Du sagst X_Null_Punkt wird zu X_Min_Wert - X_Min_Wert, setzt mal eine beliebige Zahl für X_Min_Wert ein, ob dass so viel bringt?

Gruß Der Unwissende

[Preddy2005]

Sorry das ich mich so unpräzise ausgedrückt habe, aber ich habe das selbst gecoded... Ist nicht von irgendwo abgeschrieben.
Und ich weiss auch was dort passiert. Kenne mich mit Delphi schon ganz gut aus.

Ich werde mal versuchen mein Problem zu konkretisieren...

Also der Ablauf...

1.) Wertetabelle bauen von x bis x( hier 0 bis 999) möglich
3.) X wird mit dem Schritt immer um einen konstanten Wert inkrementiert (enspricht dx := 6,28 / nmax);
2.) Y aus Sin(X) errechen
3.) Zuweisung der Werte an die Arrays
4.) Min von X - Werten und Y - Werten errechnen
5.) Nullpunktverschiebung durchführen ( durch Subtraktion des Min - Wertes) -> Nur zur Kontrollausgabe (Nullpunkt X und Y) muss nicht unbedingt im Programm enthalten sein
6.) Max X und Min Y errechen (Positiv muss es ja sein, weil negativ nicht darstellbar) , hier dann von 0 bis x und o bis y
7.) Und jetzt kommt es...

Höhe bzw Breite errechnen...

Also

System_Breite := imSystem.Width;
System_Hoehe := imSystem.Height;

Muss ich hier was noch beachten mit den Min und Max Werten oder so?


8.) H - Y Wert rechnen?

9.) Runden ... Das kann ich auch selbst .

Also bräuchte ich Hilfe bei 7 + 8 und was ich dabei beachten muss... Hoffe ich habe mich jetzt konkreter ausgedrückt.

[Der_Unwissende]

Hi,
also erstmal solltest du dir deine Berechnung der max. X- bzw. Y-Werte anschauen. Hier gäbe es einiges, was du vereinfachen kannst. Wie du schon sagst, steigt dein x in jedem Schritt um einen konst. Wert. Egal ob dieser positiv, negativ oder 0 ist, fakt ist dass du nur den ersten und letzten X-Wert beachten müsstest.
Wenn du mit x = 0 anfängst und in jedem Schritt 1 dazu addierst, nun ja, ist einfach monoton (sogar streng monoton) wachsend. Für negative Schritte gilt es analog fallend.

Was die Y-Werte angeht, so ist bräuchtest du auch nur zu schauen, ob der Wert 1 bzw. -1 erreicht wird, ist dies der Fall, so ist müsstest du schon gar nicht weitersuchen (ist halt sin), aber das ist hier egal.

Ich verstehe deine Nullpunktverschiebung noch nicht ganz. Wenn du nur im Positiven Zeichnen möchtest, so musst du nur um den negativen Wert verschieben. Du legst aber deinen Nullpunkt immer auf null, egal was du für max oder min Werte hast.

Was die Höhe oder Breite angeht, die du berechnen möchtest, so müsstest du schon etwas genauer sagen, was gegeben ist. Müsst ihr komplett selbst zeichnen? Gibt es ein Framework (also eine Funktion die ihr benutzen dürft), was sind halt die Vorgaben. In der Regel hast du einfach einen Canvas (eine Zeichenfläche) auf die du zeichnest.
Ich weiß nicht ob du den kennst, aber da findest du ne Menge zu in der Delphi-Hilfe. Ein Canvas wird dabei an sehr vielen Stellen benutzt, sowohl zum zeichnen in eine Bitmap, auf dein Form oder auf dem Drucker kommen einfach nur Canvas vor (die unterscheiden sich zwar, aber du kannst alle wie ein TCanvas behandeln).
Jedenfalls wirst du in der Regel eine feste Größe des Canvas haben, sagen wir du machst das mit einer Bitmap, dann ist die größe der Bitmap = Größe des Canvas.
Du weißt also wie groß deine Zeichenfläche ist und du weißt wieviele Punkte in x Richtung du zeichnen möchtest und wie viele in Y Richtung (halt Maximum - Minimum viele).
Jetzt musst du dass alles nur noch geschickt skalieren. Dazu brauchst du eigentlich nur den Dreisatz (gibt auch andere Wege, aber die will dein Lehrer sicher nicht sehen und sie würden dir weniger bringen). Du hast einfach nur ein Verhältnis dass du ausrechnen möchtest. Wenn du nicht genau weißt wie, dann überleg es dir an einem einfachen Beispiel. Geh davon aus, dass deine Bitmap genau 100 px hat, und du 10 Punkte zeichnen möchtest. Der erste Punkt liegt auf der 0,... Da kannst du also leicht berechnen, mit was du 10 multiplizierst, damit er möglichst exakt auf 100 liegt.
Dann mach es mal umgekehrt, du hast eine 10 px breite Bitmap und willst 100 Punkte zeichnen. Da jeder Punkt mindestens 1 px breit ist, kannst du also nur 10 punkte zeichnen. Das heißt du wirst wohl nicht alle nehmen können (auch hier kannst du schon im Kopf ausrechnen wieviele es sind).
Das was du im Kopf rechnest, ist natürlich auch durch den Rechner berechenbar. Und wenn du die Zahlen änderst, kann er dass immer noch ganz gut. Wichtig ist es also für dich, zu gucken ob du mehr Punkte zeichnen möchtest (in x Richtung) als du Pixel in der Bitmap hast. Ist dies der Fall, kannst du nicht jeden Punkt (in X Richtung) zeichnen. In Y-Richtung kannst du halt einen Rundungsfehler hinnehmen, so exakt muss es da nicht sein. Aber wenn du zwei Y-Werte am selben Pixel (X-Wert) zeichnest, sieht es nicht mehr nach einer Funktion aus (die hat max. einen Y-Wert pro X-Wert).
Hoffe ist grob klar was ich meine.

Jedenfalls ist das schon alles. Du berechnest die x und die y Skalierung (Verhältnis von Breite zu Anzahl der X-Werte und Verhältnis von Höhe zu Anzahl der y-Werte) und multiplizierst jeden Wert entsprechend.

Das ist auch alles was du bei H-Y beachten musst, du musst vorher skalieren. Wie du sicherlich weißt nimmt die Sinus Funktion über 2pi Werte von -1 bis 1 an. Das könntest du in 3 Pixel packen (1, 0, -1) und deine Funktion würde einfach nicht nach Sinus aussehen. In der Regel ist dein Bild deutlich höher als 3 Pixel. Dann skalierst du auch deine Werte entsprechend und siehst auch entsprechend mehr Zwischenwerte.

Gruß Der Unwissende

[Preddy2005]

Ok das hilft mir alles schon sehr viel mehr... Genau das was ich gebraucht habe. Es gibt übrigens keine Restriktionen und ich werde das später noch alles in Funktionen packen. Die Restriktionen sind das, was ich programmieren kann . Und mit Canvas kenne ich mich auch aus. Da brauche ich wenig Hilfe.Werde mich dann später nochmal melden wenn ich nicht weiterkommen sollte.

Nochmals vielen Dank dafür.

[Preddy2005]

Also ich habe deine Vorschläge mal in mein Programm versucht einzubauen. Wegen der X - Y Berechnung : Man kann am Anfang die Anzahl eingeben und die Schritte, deswegen habe ich das so umständlich gelöst. Normalerweise könnte man auch ein Konstante verwenden, ich fand diese Methode besser.

Das einzige wo ich mir nicht sicher bin ist die Skalierung ? Verstehen tu ich es, allerdings weiss ich nicht ob ich es korrekt in Delphi umgesetzt habe. Hier nochmal mein Code:

Delphi-Quellcode:

procedure TfrmFunktionsplotter.btnAusgabeClick(Sender: TObject);
var Anzahl_n             :  Integer;
    i, j, k, l, m        :  Integer;
    Schritt              :   Double;
    Y_Max_Wert           : Extended;
    X_Max_Wert           : Extended;
    Y_Min_Wert           : Extended;
    X_Min_Wert           : Extended;
    Y_Max_Min            : Extended;
    X_Max_Min            : Extended;
    Y_Temp_Max           : Extended;
    X_Temp_Max           : Extended;
    Y_Temp_Min           : Extended;
    X_Temp_Min           : Extended;
    Y_Null_Punkt         : Extended;
    X_Null_Punkt         : Extended;
    Skalierung_Faktor_Y  : Extended;
    Skalierung_Faktor_X  : Extended;

begin

     Y_Max_Wert     := 0;
     Y_Min_Wert     := 0;
     X_Max_Wert     := 0;
     X_Min_Wert     := 0;
     Y_Null_Punkt   := 0;
     X_Null_Punkt   := 0;

     Anzahl_n := StrToInt((edtAnzahln.Text));
     Schritt := StrToFloat(edtSchritt.Text);

         { Schritt 1 : Wertetabelle erstellen für die Berechnung
          X aus den Schritten und Y wird aus Sin(x) errechntet }

     for i:= 0 to Anzahl_n do
      begin

       X_Werte_Array[i+1] := X_Werte_Array[i] + Schritt;
       Y_Werte_Array[i+1] := Sin(X_Werte_Array[i]);

       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('Wert von  X : ' + FloatToStr(X_Werte_Array[i]));
       memAusgabe.Lines.Add('Sin   von   X : ' + FloatToStr(Y_Werte_Array[i]));
       memAusgabe.Lines.Add('');

      end;

                { Schritt 2 : Min und Max von Y bestimmen
                 Max Y kann nicht größer  als  1 sein
                 Min Y kann nicht kleiner als -1 sein
                 Wenn größer, dann auf eins runden }

                // Max Y

       for k:= 0 to Anzahl_n do
        begin

         Y_Temp_Max := Y_Werte_Array[k];
          if (Y_Temp_Max > Y_Max_Wert)
           then Y_Max_Wert := Y_Temp_Max;

            if ( Y_Max_Wert > 1) then
             begin
              Y_Max_Wert := 1;
              break;
             end;
        end;

                // Min Y

        for  j := 0 to Anzahl_n do
         begin

          Y_Temp_Min := Y_Werte_Array[j];
           if (Y_Temp_Min < Y_Min_Wert)
            then Y_Min_Wert := Y_Temp_Min;

            if ( Y_Max_Wert < - 1) then
             begin
              Y_Min_Wert := -1;
              break;
             end;
         end;

                    // Max X

           for l := 0 to Anzahl_n do
            begin
             X_Temp_Max := X_Werte_Array[l];
              if (X_Temp_Max > X_Max_Wert)
               then X_Max_Wert := X_Temp_Max;
             end;

                       // Min X

           for m := 0 to Anzahl_n do
            begin
             X_Temp_Min := X_Werte_Array[m];
              if (X_Temp_Min < X_Min_Wert)
               then X_Min_Wert := X_Temp_Min;
             end;

       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('Y Max-Wert :  ' + FloatToStr(Y_Max_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('Y Min-Wert :  ' + FloatToStr(Y_Min_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('X Min-Wert :  ' + FloatToStr(X_Min_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('X Max-Wert :  ' + FloatToStr(X_Max_Wert));
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');

       // Schritt 3 : Nullpunktverschiebung durch Subtraktion des Min - Wertes


       if ( Y_Min_Wert < 0) then Y_Null_Punkt := Y_Min_Wert - Y_Min_Wert;
       if ( X_Min_Wert < 0) then X_Null_Punkt := X_Min_Wert - X_Min_Wert;

       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('Y - Nullpunkt nach Verschiebung: ' + FloatToStr(Y_Null_Punkt));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('X - Nullpunkt nach Verschiebung: ' + FloatToStr(X_Null_Punkt));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');

                         // Schritt 4 : Max - Min berechnen

       X_Max_Min   := X_Max_Wert - X_Min_Wert;
       Y_Max_Min   := Y_Max_Wert - Y_Min_Wert;
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('X Max/Min Wert: ' + FloatToStr(X_Max_Min));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('Y Max/Min Wert: ' + FloatToStr(Y_Max_Min));
       memAusgabe.Lines.Add('');
       memAusgabe.Lines.Add('************************************************');
       memAusgabe.Lines.Add('************************************************');

                // Schritt 5 : h (bzw. b) (Max - Min) errechnen

       System_Breite  := imSystem.Width;
       System_Hoehe   := imSystem.Height;

                            { Skalierung
   Sind    mehr Punkte vorhanden als die Größe der Canvas darstellen kann?
   Sind weniger Punkte vorhanden als die Größe der Canvas darstellen kann

            // 100  Punkte        100  Pixel    1 :1
            // 100  Punkte         10  Pixel   10 :1
            // 10   Punkte        100  Pixel    1 :10

                 // Weniger Punkte als Zeichenfläche
   //  10 Punkte  = 500 Pixel = System_Breite / Anzahl_n; Faktor : 50

                 // Mehr Punkte als Zeichenfläche
   // 500 Punkte =  10 Pixel = System_Breite / Anzahl_n; Faktor : 0.02  }

       if (Anzahl_n > System_Breite) or (Anzahl_n < System_Breite)
        then Skalierung_Faktor_X := System_Breite / Anzahl_n;

        if (Anzahl_n > System_Hoehe) or ( Anzahl_n < System_Hoehe)
         then Skalierung_Faktor_Y := (System_Hoehe / Anzahl_n);

end;

Hoffe du kannst mir erneut helfen und sagen was daran falsch ist, falsch was falsch ist. Ansonsten schonmal ein riesen Dankeschön für die Hilfe.