Probleme mit Sinus Darstellung

[Chris211183]

Hallo DP´ler,

ich möchte einen SinusGraphen auf meiner Komponentenoberfläche anzeigen lassen. Bekomme das aber absolut nicht hin. Die Mathematik ist hier nicht das Problem, sondern die Programmierung.

Brauche denfinitiv Hilfe und es wäre toll, wenn sich jemand erbarmen würde :gruebel:

Delphi-Quellcode:

procedure THixHistoGraph.DrawGridScale;

var
a, b, c, d, x1, x2 , fvonx1, fvonx2  : Real;
i: Integer;                                                                       

begin

   a  := FXScale.ValMin;                               // Null (0/0) von X- und Y- Koordinate
   b  := FXScale.ValMax;                               // Width
   c  := FYScale.ValMin;                               // Anfang der Y-Achse
   d  := FYScale.ValMax;                               // Ende Der Y-Achse
   x1 := ViewXNominalMin;                              // Punkt, von wo aus gezeichnet werden soll
   x2 := ViewXNominalMax;                              // Punkt, bis wohin gezeichnet werden soll


   for i := 0 to Round(2*pi/0.2) do
   begin
   fvonx1 := (Width div (b-a)) + x1* ((a*Width) div (a-b));      // Funktionswert an der Stelle x1
   fvonx2 := (Height div (d-c)) + x2* ((c*Height)div (c-d));    // Funktionswert an der Stelle x2
   end;

  with FBmp.Canvas do
  begin
  //canvas.MoveTo(fvonx1, d);

  end;

end;

[DeddyH]

Die For-Schleife ist sinnbefreit, da mit den errechneten Werten nichts gemacht wird. Ansonsten: ich bin nicht so der Mathe-Crack, aber ich denke, Du suchst so etwas wie Bezierkurven.

[Chris211183]

Ja, die ist noch aus dem Probiervorgängen der letzten Tage drin !

Ich guck mir das mal mit den Beziers an.

[Chris211183]

Also Beziers benötige ich nicht....

den Funktionswert von X2 benötige ich auch nicht, er soll einfach von einem erstmal beliebigen Punkt, bis zum ende einen Sinus zeichnen, das ist das Problem, die Parametrisierung kann ich selber machen

Das kann doch nicht so schwer sein:oops:

glaub der Fehler liegt bei mir zwischen den Ohren...

oder über nen Array....., ich geh hier bald krachen:evil::wall:

[Headbucket]

Hey,

hier mal ein kleines Beispiel. Auf deinem Form sollte bereits ein "TImage" namens "Image1" liegen. Dann folgende Prozedur aufrufen.

Delphi-Quellcode:

procedure TForm1.DrawWaveForm;
var
  Bitmap: TBitmap;
  i, Start: integer;
begin
  Bitmap := TBitmap.Create;
  Bitmap.Width := Image1.Width;
  Bitmap.Height := Image1.Height;
  Bitmap.Canvas.Brush.Color := clMaroon;
  Bitmap.Canvas.Fillrect(Image1.Canvas.ClipRect);
  Bitmap.Transparent := true;
  Bitmap.TransparentColor := clMaroon;
  Bitmap.Canvas.Pen.Color := clBlack;
  Bitmap.Canvas.Pen.Width := 1;
  Start := Image1.Height div 2; //Sinuskurve im Nulldurchgang beginnen -> In der Mitte

  Bitmap.Canvas.MoveTo(0, Start);
  for i := 0 to Image1.Width - 1 do
    Bitmap.Canvas.LineTo(i, Start - Trunc(Start * sin(2*pi*(1/Image1.Width)*i)));
  
  Image1.Transparent := true;
  Image1.Picture.Assign(Bitmap);
  Bitmap.Free;
end;

Grüße
Headbucket

[Chris211183]

Danke für eure Antworten, ich habe nen kompletten Denkfehler gemacht !

Im Prinzip sollen ja Messwerte visuell als Kurve dargestellt werden, also brauch ich wohl nen Array.
Wie stellt man sowas an ? Wie lässt man einen Array dann zeichnen :gruebel:

Google habe ich bereits gequält und das Forum ebenso, aber so richtig was finde ich nicht darüber.

[Headbucket]

Also irgendwie verstehe ich nicht, wo aktuell das Problem liegt bzw. was du überhaupt GENAU machen möchtest.
Kannst du das vllt nochmal genauer beschreiben?

Zum Zeichnen kann man das Canvas-Objekt verwenden. Dazu solltest du reichlich informationen über Google finden.
Ein Beispiel zum Zeichnen einer Sinusfunktion (eine Periode) habe ich dir bereits gegeben. Hast du dir das Beispiel angeschaut? Gibt es dazu fragen?
Wenn du das Beispiel verstehst sollte doch alles klar sein?

Mit Canvas.LineTo(X, Y) zeichnest du eine Linie von der aktuellen Position zum Punkt X,Y. Die aktuelle Position änderst du mit Canvas.MoveTo(X, Y).
Genau das habe ich in meinem Beispiel auch gemacht.
Zunächst die Position auf den Nullpunkt gelegt und danach für alle X-Werte den Y-Wert berechnet und gezeichnet.

Natürlich kannst du die X- und Y-Werte auch vorher berechnen und in ein Array schmeißen. Dann musst du lediglich über eine Schleife die Werte aus den Array auslesen und mit LineTo zeichnen.

Grüße
Headbucket

[Chris211183]

Hi,

das zeichnen an sich ist kein Problem, über canvas habe ich ja meine Komponente gezeichnet.

Ich möchte jediglich mit meiner Komponente später Messwerte (wie ein Oszilloskop) anzeigen lassen.
Jetzt geht es mir darum, wie man das am besten und wie programmiert, damit diese das auch später macht.
Ich bin nur Hobbyprogrammierer und bin daher nicht so fit in den Dingen, bring mir das alles selbst bei und daher auch manchmal so wirre und "dusselige" Fragen !

:cheers::cheers:

[DeddyH]

Hier z.B. werden die Punkte zunächst errechnet, in einem Array gespeichert und dann mit TCanvas.PolyLine in einem Rutsch gezeichnet.

[Chris211183]

Genau sowas habe ich gesucht !!! Super Klasse, danke euch für eure Mühe !!!:thumb:

[Bjoerk]

Möchtest du eine stehende Welle zeichnen oder eine simple Sinuskurve? Vom Graph her sieht die Kurve am besten aus wenn man je Pixel X einen Y-Wert berechnet und zeichnet (for I := 0 to Width -1 do). Man braucht Skalierungsfunctions die Pixel in Funktionswerte umrechnen und umgekehrt. Üblicherweise gibt man bei einem Mouse Move über die Grafik die entsprechenden Werte in z.B. einer Statusbar numerisch aus (X = .. / Y = ..).

[Chris211183]

Hi, ich möchte eine stehende Welle zeichnen !

Dein Vorschlag klingt sehr gut, jedoch übersteigt das meine Programmierkenntnisse bei weitem.

[Chris211183]

Hier mal mein Code, im Anhang ein Screenshot:

Prinzipiell das, was es machen soll, sieht bloß ekelig aus :duck:

Delphi-Quellcode:

FPoints                   : Array[0..144] of TPoint;
.
.
.
procedure THixHistoGraph.DrawGridScale;

var
XRangePixels, YRangePixels: Double;
Start: TPoint;
Radian, Interval: Double;
i : Integer;

begin
   XRangePixels := (Width - GapLeft- GapRight) / (FXScale.ValGap);
   YRangePixels := (Height - GapTop - GapBottom) / (FYScale.ValGap);
   Start := Point(GapLeft, Height - GapBottom);
   Radian :=   (FXScale.ValMin) * PI;
   Interval := (FXScale.ValMax + FXScale.ValMin) * PI / 144;

   for i:= 0 to High(FPoints) do
   begin
     FPoints[i].X := Start.X + round(Radian * xRangePixels / Pi);
     FPoints[i].Y := Start.Y - round(sin(Radian) * yRangePixels);
     Radian := Radian + Interval;
   end;
   Canvas.Pen.Color := cllime;
   Canvas.Polyline(FPoints);
end;

[Caps]

Hi,

ich glaube es wäre sinnvoll, die Mathematik von der Darstellung zu trennen.

In den Zeilen

Code:

FPoints[i].X := Start.X + round(Radian * xRangePixels / Pi);
FPoints[i].Y := Start.Y - round(sin(Radian) * yRangePixels);

verwendest Du Darstellungskoordinaten (xRangePixels, yRangePixels) und "mathematische" Koordinaten (Radian, FPoints[i].X, FPoints[i].Y).
Meiner Ansicht nach wäre es besser, zuerst die 144 Samples der Funktion zu berechnen. D.h. "mathematisches" Argument wird auf "mathematischen" Funktionswert abgebildet. Du hättest dann ein Array of Float o.ä.
Danach nimmst Du dieses Array von Float-Werten, skalierst die Werte, bis sie groß genug sind, um in Pixeln sinnvoll dargestellt zu werden und rundest sie, so dass Integers rauskommen.
Im dritten Schritt transformierst Du diese Werte in das Koordinatensystem Deiner Darstellungskomponente.
Dann kannst Du Polyline drauf loslassen.

lg Caps

[Chris211183]

oha :pale:

das alles zu berechnen ist ja nicht das schwierigste, aber wie zur Hölle programmiert man sowas...

In solchen Sachen bin ich noch Jungfrau...

[Caps]

Aber nicht doch ;-).

Du hast doch alles schon gemacht. Ein bisschen Addieren, Multiplizieren, mehr ist es doch nicht.
Und die Darstellung machst Du doch auch schon.
Was ist jetzt noch das schwere?

lg Caps

[Chris211183]

:glaskugel: ich habe mein Source jetzt bestimmt schon 4 mal geändert und es wird immer übler in der Darstellung :roteyes:

ich check grad garnüscht mehr...

Zeichnet über die Ränder find die sch... Fehler aber nicht.

Der Soll einfach ne stehende Welle von X-Achse-Anfang bis X-Achse Ende machen über die Höhe Y, das ist doch nicht so schwer..., ich bekomm das einfach nicht gebacken...

[Caps]

Hast Du's denn probiert wie ich schrieb, Mathematik und Darstellung zu trennen?
Wenn Du die Samples von der Sinusfunktion berechnet hast, ist die halbe Miete drin.
Dann brauchst Du die Werte nur noch mit einer großen Zahl multiplizieren (z.B. 100), runden (mit round()) und fertig sind Pixelwerte. Dat is doch nu nix schlimmes mehr :-D.

[Blup]

An der Sinusfunktion is ja erst mal nichts besonderes:

y := f(x)

Dann haben wir ein Rechteck als Zeichenfläche:

R: TRect

Den Wert von X für die erste linke Pixelspalte und Y für die oberste Pixelzeile auf der Zeichenfläche:

x0: Double
y0: Double

Die Breite und Höhe eines Pixels in unserem skalliertem Koordinatensystem:

dx: Double
dy: Double

Die verallgemeinerte Aufgabe ist die Berechnung der Punkte für die Darstellung einer beliebigen f(x)-Funktion:

Delphi-Quellcode:

type
  TFxFuntion = function(const x: Extended): Extended;
  TPointDynArray = array of TPoint;

function BerechnePunkteDarstellung(AFunc: TFxFuntion; const ARect: TRect; x0, y0, dx, dy: Double): TPointDynArray;
var
  x, y: Double;
  i: Integer;
begin
  {für jede Spalte einen Punkt}
  SetLength(Result, ARect.Right - ARect.Left + 1);
  {Punkte berechnen}
  x := x0;
  for i := Low(Result) to High(Result) do
  begin
    y := AFunc(x);
    {unser Koordinatensystem steht auf dem Kopf}
    y := -y;
    {oberen Rand addieren}
    y := y0 + y;
    {skallieren}
    y := y / dy;
    {runden}
    Result[i].x := ARect.Left + i;
    Result[i].y := ARect.Top  + Round(y);
    {nächster Punkt}
    x := x + dx;
  end;
end;

procedure ZeichnePunkteDarstellung(ACanvas: TCanvas; const ARect: TRect; const APoints: TPointDynArray);
var
  h: THandle;
begin
  h := SaveDC(ACanvas.Handle);
  try
    {Zeichenfläche einschränken}
    IntersectClipRect(ACanvas.Handle, ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
    Polyline(ACanvas.Handle, APoints[0], Length(APoints));
  finally
    RestoreDC(ACanvas.Handle, h);
  end;
end;

procedure TFTest.PaintBox1Paint(Sender: TObject);
var
  R: TRect;
  x0, y0, dx, dy: Double;
  P: TPointDynArray;
begin
  with TPaintBox(Sender) do
  begin
    R := ClientRect;
    {Hintergrund}
    Canvas.Brush.Color := clGray;
    Canvas.Brush.Style := bsSolid;
    Canvas.FillRect(R);
    Canvas.Brush.Style := bsClear;
    {ein Rechteck}
    InflateRect(R, -10, -10);
    Canvas.Pen.Color := clBlack;
    Canvas.Pen.Width := 1;
    Canvas.Rectangle(R);
    {darin der Graph}
    InflateRect(R, -1, -1);
    {Parameter initialisieren}
    x0 := 0;
    y0 := 3;
    dx := 0.05;
    dy := 0.05;
    P := BerechnePunkteDarstellung(sin, R, x0, y0, dx, dy);
    Canvas.Pen.Color := clLime;
    ZeichnePunkteDarstellung(Canvas, R, P);
  end;
end;

[Chris211183]

Ihr seid die Besten !

Vielen Dank an euch, jetzt funzt es so wie das soll:thumb: !

Schick schönes Wochenende euch !!!

:cheers:

[Bjoerk]

Eine stehende Welle könnte man in den Code in etwa so implementieren (hab den Code von Blup jetzt aber nicht probiert).

Delphi-Quellcode:

function FX1(const X: double): double;
begin
  Result := 2 * Sin(X + DeltaX);
end;

function FX2(const X: double): double;
begin
  Result := 2 * Sin(DeltaX - X + Pi);
end;

function FX3(const X: double): double;
begin
  Result := FX1(X) + FX2(X);
end;

procedure TFTest.StartDrawButtonClick(Sender: TObject);
begin
  DeltaX := 0;
  DrawTimer.Interval := 50;
  DrawTimer.Enabled := true;
end;

procedure TFTest.StopDrawButtonClick(Sender: TObject);
begin
  DrawTimer.Enabled := false;
end;

procedure TFTest.DrawTimerTimer(Sender: TObject);
begin
  DrawTimer.Enabled := false;
  try
    PaintBox1.Invalidate;
    DeltaX := DeltaX + PI / 18;
    Application.ProcessMessages;
  finally
    DrawTimer.Enabled := true;
  end;
end;


procedure TFTest.PaintBox1Paint(Sender: TObject);
..
    P := BerechnePunkteDarstellung(FX1, R, x0, y0, dx, dy);
    Canvas.Pen.Color := clBlue;
    ZeichnePunkteDarstellung(Canvas, R, P);

    P := BerechnePunkteDarstellung(FX2, R, x0, y0, dx, dy);
    Canvas.Pen.Color := clRed;
    ZeichnePunkteDarstellung(Canvas, R, P);

    P := BerechnePunkteDarstellung(FX3, R, x0, y0, dx, dy);
    Canvas.Pen.Color := clLime;
    ZeichnePunkteDarstellung(Canvas, R, P);
  end;
end;

[Chris211183]

Zitat:

Zitat von Blup (Beitrag 1291639)

P := BerechnePunkteDarstellung(sin, R, x0, y0, dx, dy);

[/delphi]

hier meckert er, in dieser Zeile !

( erwartet aber , gefunden ???:gruebel:

habe das so probiert

Delphi-Quellcode:

P := CalculatePointView(sin(r,x0, y0, dx, dy));

dann kommt inkompatible Typen....

hat mein Compiler heute Montag oder was ist daran falsch ???

[DeddyH]

Die Typdeklarationen hast Du aber mit kopiert?

Zitat:

Delphi-Quellcode:

type
  TFxFuntion = function(const x: Extended): Extended;
  TPointDynArray = array of TPoint;

[Chris211183]

na logo, alles wie beschrieben und auf mein Code umgesetzt ! das ist auch das Einzige, was rumzickt

[Chris211183]

Delphi-Quellcode:

type
   TFxFunction = function(const x: Extended): Extended;
   TPointDynArray = array of TPoint;




function CalculatePointView
(AFunc: TFxFunction; const ARect: TRect; x0, y0, dx, dy: double): TPointDynArray;
var
  x, y: double;
  i : integer;
begin                                                                           // für jede Spalte einen Punkt
   SetLength(Result, ARect.Right - ARect.Left +1);                              // Punkte berechnen
   x := x0;
   for i := Low(Result) to High(Result) do
   begin
   y := AFunc(x);
   y := -y;                                                                     // Canvas Nullpunkt obere linke Ecke mit Y- Achse nach unten !!!
   y := y0 + y;                                                                 // oberen Rand Addieren
   y := y / dy;                                                                 // Skalieren
   Result[i].x := ARect.Left +1;
   Result[i].Y := ARect.Top + Round(y);                                         // runden
   x := x + dx;
   end;                                                                         // nächster Punkt
end;

procedure DrawPointView
(ACanvas: TCanvas; const ARect: TRect; const APoints : TPointDynArray);
var
  h : Thandle;
   begin
   h:= SaveDC(ACanvas.Handle);
   try
   IntersectClipRect(ACanvas.Handle, ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
   Polyline(ACanvas.Handle, APoints[0], Length(APoints));
   finally
      RestoreDC(ACanvas.Handle, h);
   end;
end;

procedure THixHistoGraph.DrawFunction;
var
  R :TRect;
  x0, y0, dx, dy :double;
  P: TPointDynArray;
  begin
   R := Rect (GapLeft,
              GapTop,
              Width - GapRight + 2,
              Height - GapBottom);
   Canvas.Brush.Color := FHistoBkColor;
   Canvas.Pen.Color   := FHistoBkColor;
   Canvas.Pen.Style   := psSolid;
   Canvas.FillRect(R);
   InflateRect(R, -1, -1);
   x0 := 0;
   y0 := 3;
   dx := 0.05;
   dy := 0.05;
   P := CalculatePointView(sin, R, x0, y0, dx, dy));
   Canvas.Pen.Color := cllime;
   CalculatePointView(Canvas, R, P);
end;

[Blup]

TFxFunction wurde mit Extendet-Parameter und -Rückgabewert deklariert, da die sin-Funktion in Unit Math so deklariert ist.

Entweder du stellst die Definition auf Double um oder die Parameter und Rückgabewerte der neuen Funktionen auf Extendet.

[Chris211183]

Ahhhh, jetzt ja ! Danke !

Ihr seid immer wieder klasse ! Da lernt man richtig was !

[Chris211183]

Okay, hab jetzt alle als Extended deklariert, er macht glaube ich mucken mit dem Rectangle, da dieses ja Rückgabewerte vom Typ Integer hat.

habs mit Trunc und Round probiert, meckert er weiter, vonwegen inkompatible Typen...

[DeddyH]

Siehe Kommentar

Zitat:

Delphi-Quellcode:

P := CalculatePointView(sin, R, x0, y0, dx, dy));
   Canvas.Pen.Color := cllime;
   CalculatePointView(Canvas, R, P); //<-- Sollte das nicht eher DrawPointView heißen?

[Chris211183]

Stimmt, denn och ändert das die Typeninkompatibilität nicht....


Hier nochmal mein Code mit den Änderungen

Delphi-Quellcode:

TFxFunction = function(const x: Extended): Extended;
TPointDynArray = array of TPoint;



function CalculatePointView
(AFunc: TFxFunction; const ARect: TRect; x0, y0, dx, dy: Extended): TPointDynArray;
var
  x, y: Extended;
  i : integer;
begin                                                                           // für jede Spalte einen Punkt
   SetLength(Result, ARect.Right - ARect.Left +1);                              // Punkte berechnen
   x := x0;
   for i := Low(Result) to High(Result) do
   begin
   y := AFunc(x);
   y := -y;                                                                     // Canvas Nullpunkt obere linke Ecke mit Y- Achse nach unten !!!
   y := y0 + y;                                                                 // oberen Rand Addieren
   y := y / dy;                                                                 // Skalieren
   Result[i].x := ARect.Left +1;
   Result[i].Y := ARect.Top + Round(y);                                         // runden
   x := x + dx;
   end;                                                                         // nächster Punkt
end;

procedure DrawPointView
(ACanvas: TCanvas; const ARect: TRect; const APoints : TPointDynArray);
var
   h : Thandle;
   begin
   h:= SaveDC(ACanvas.Handle);
   try
   IntersectClipRect(ACanvas.Handle, ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
   Polyline(ACanvas.Handle, APoints[0], Length(APoints));
   finally
      RestoreDC(ACanvas.Handle, h);
   end;
end;

procedure THixHistoGraph.DrawFunction;
var
  R :TRect;
  x0, y0, dx, dy :Extended;
  P: TPointDynArray;
  begin
   R := Rect (trunc(FGapLeft),
              trunc(FGapTop),
              trunc(Width - FGapRight + 2),
              trunc(Height - FGapBottom));

   Canvas.Brush.Color := FHistoBkColor;
   Canvas.Pen.Color   := FHistoBkColor;
   Canvas.Pen.Style   := psSolid;
   Canvas.FillRect(R);
   InflateRect(R, -1, -1);
   x0 := 0.0;
   y0 := 3.0;
   dx := 0.05;
   dy := 0.05;
   P := CalculatePointView(sin, R, x0, y0, dx, dy));
   Canvas.Pen.Color := cllime;
   DrawPointView(Canvas, R, P);
end;

[DeddyH]

Was wird denn wo genau angemeckert? Beim schnellen Überfliegen kann ich keine Fehler feststellen.

[Chris211183]

steht nur inkompatible Typen (auch nicht welche) und er geht mit dem Kursor direkt hinter das R nach sin

(sin, R, x0..........)

[DeddyH]

Da ist eine schließende Klammer zu viel, sonst sehe ich nichts, was eine Fehlermeldung auslösen könnte.

[Chris211183]

ich auch nicht, steht auch nicht, welche Inkompatiblen Typen....

[DeddyH]

Kann ich nicht nachvollziehen.

[Chris211183]

Delphi-Quellcode:

P := CalculatePointView(sin, R, x0, y0, dx, dy);

Hier kommt die Meldung `(` erwartet, aber `,`gefunden)

[DeddyH]

Versuch mal

Delphi-Quellcode:

P := CalculatePointView(@sin, R, x0, y0, dx, dy)

[Chris211183]

selbe Fehlermeldung Klammer erwartet Komma gefunden:gruebel:

was bewirkt das @ ?

[DeddyH]

Das @ sollte dem Compiler mitteilen, dass es sich um die Adresse der Funktion handelt und nicht um das Ergebnis derselben. Kannst Du das Projekt mal zippen und anhängen, ich denke fast, der Fehler liegt an einer ganz anderen Stelle, die wir gar nicht sehen?

[Chris211183]

Ist im Anhang !