Probleme mit Sinus Darstellung

[Chris211183]

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

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 .

[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 !

Schick schönes Wochenende euch !!!

[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 von Blup:

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

[/delphi]

hier meckert er, in dieser Zeile !

( erwartet aber , gefunden ???

habe das so probiert

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;