Orientierungspunkte für die Y-Achse eines Diagramms berechnen

[Sigi Sandl]

Hallo, Harry Stahl,

hier mein Quellcode zum Zeichnen einer Y-Achse aus vorgegebener Wertetabelle.
Teile davon sind zwanzig Jahre alt, Teile davon kann ich auf die Schnelle nicht mehr nachvollziehen, Teile sind durch Ausprobieren entstanden, geschrieben in D7.
Alles andere hab' ich versucht, einigermaßen zu kommentieren.
Für das Format des Postings entschuldige ich mich, besser kann ich's nicht.
Dann hoffe ich nur noch, daß Du was damit anfangen kannst.

Gruß
Sigi

--------------------------------------------------------------------------

Funktionen, hab' ich irgendwo abgeschrieben, was die genau machen, weiß ich nicht mehr
--------------------------------------------------------------------------------------

function Pot(Basis,Exponent : LongInt) : LongInt;
var
P : real;
n : word;
begin
P := 1;
for n := 1 to exponent do
P := P * Basis;
Pot := Trunc(P);
end;


Function Basis(W : LongInt) : LongInt;
var
n : word;
wert : LongInt;
begin
n := 0;
while (W div Pot(10,n)) > 0 do
inc(n);
Basis := Pot(10,n-1);
end;

-------------------------------------------------------------------
Im Hauptformular steht:
-------------------------------------------------------------------

var
CPC : TCanvas;
xL, yO, xR, yU : integer;
CxL, CyO, CxR, CyU : integer;
B, BC, H : integer;

IMin, IMax : Integer; // Kleinster und größter Y-Wert
Interval : Real; // davon das interval
TeilerY : integer; // Y-Achsen-Abschnitt
ARY : Real; // AspektRatio zum Zeichnen

FKx, FKy, FKxL, FKxR, FKyO, FKyU : integer;

PFirstPoint,
PLastPoint : TKurs;



Function GetRelativKoordinate(R : Real) : word;
begin
Result := yU - Trunc((ARY *((Log2(Max(R,1)))-(Log2(Max(Imin,1)))))); // yU = Diagramm Unten
end; // für absolute Darstellung die log2-Funktion weglassen


--------------------------------------------------------------------------
Y-Achse berechnen und zeichnen, der Nullpunkt des Canvas ist LinksOben
--------------------------------------------------------------------------



PLastPoint := TKurs(AktKursliste.Last); // Meine WerteListe


PK := PLastPoint;
K1 := MaxInt;
G1 := 0;
while (PK <> PFirstPoint) do // größten und kleinsten Y-Wert ermitteln
begin
K1 := Min(K1,PK.GetMinimum);
G1 := Max(G1,PK.GetMaximum);
PK := TKurs(AktKursliste.GetPrev(PK));
end;
IMin := trunc(K1/1.02); // IMin verkleinern
IMax := trunc(G1*1.02); // IMax vergrößern
Interval := (IMax-IMin+1); // damit ich nicht bis an die Grenzen zeichne

TeilerY := Basis(Trunc(Interval)); // Y-Achsen-Abschnitt berechnen
while ((Interval/TeilerY) < 4) do teilerY := TeilerY div 2; // ist durch Ausprobieren entstanden
Interval := (log2(IMax)) - (log2(Max(IMin,1))); // Interval berechnen, für absolute Darstellung die log2-Funktion weglassen
ARY := (H/Interval); // AspektRatio berechnen, H = DiagrammHöhe

n := IMin; // Zeichnen
while ((n mod teilerY) <> 0) do inc(n); // durch Ausprobieren entstanden
while (n <= IMax) do
begin
if ((n mod TeilerY) = 0) then Ky := GetRelativKoordinate(n);
R := n;
if (Frac(R/ChF) <> 0)
then S := FloatToStrF(R/ChF,ffFixed,6,2)
else S := FloatToStrF(R/ChF,ffFixed,6,0);
CPC.Pen.Style := PsSolid;
CPC.Font.Color := ClBlack;
CPC.Brush.Style := BsClear;
CPC.TextOut(xL-10-CPC.Textwidth(S),round(ky-CPC.TextHeight(S) div 2),S);
CPC.TextOut(xR+10,round(ky-CPC.TextHeight(S) div 2),S);
CPC.Pen.Style := PsDot;
CPC.Pen.Color := ClGray;
CPC.Pen.Width := 1;
CPC.MoveTo(CxL-20,Round(Max(Ky,CyO))); CPC.LineTo(CxR+20,round(Max(Ky,CyO)));
Inc(n,TeilerY);
end;

[Namenloser]

Ich habe vor Jahren auch mal sowas programmiert. Weiß aber auch nicht mehr, was ich damals genau gemacht habe. In dem Code steckt offenbar einiges "Engineering" drin

Die Grundidee ist, dass man mit der Konstanten GRID_APROX_PIXEL_DIST den Abstand (in Pixeln) festlegt, den aufeinanderfolgende Achsenabschnitte "ungefähr" haben sollten. Der Code wählt dann automatisch passende "schöne" Schrittweiten für die Achsenbeschriftungen wie z.B. (10, 20, 30, 40, ...) oder (20, 40, 60, 80, ...) oder (50, 100, 150, 200, ...) etc.

Weiß nicht, ob jemand mit dem Code etwas anfangen kann, aber macht damit was ihr wollt.

Edit: Habe noch einen Screenshot angehängt, wie das beispielsweise aussieht. Die Einteilung ändert sich dynamisch, wenn man die Fenstergröße verwändert.

[Harry Stahl]

Vielen Dank erst mal für die Rückmeldungen.

Um die Frage noch einmal etwas zu verdeutlichen ein Demo-Projekt (VCL) im Anhang. Siehe auch screenshot. Wenn man die einzelnen Schalter Random... drückt, wird eine Chart mit den jeweiligen x-Werten erzeugt und links auf der Y-Achse die passenden Werte angezeigt.

Das sind mal Schritte im Abstand von 50, mal 100, mal 1000, mal 100.000 usw.

Ich bräuchte letztlich nur eine Funktion, welche (vergleichbar dem TChart) z.B. 10 sinnvolle Werte für die Y-Achse berechnet (wie und wo die gemalt werden, ist Nebensache, es geht mir nur im die sinnvollen Zahlen).

Dabei ist schon klar, dass man, nachdem man die Zahlen erzeugt hat, den Maximalbetrag ermitteln muss (mit der MAX-Funktion). Dann reicht es aber nicht, diese Maximalzahl durch 10 zu teilen, da man da ja krumme werte bekommt. Hier geht es letztlich darum, die einzelnen Werte sinnvoll zu runden oder sonstwie zu ermitteln.

[samso]

Ich formuliere die Anforderung mal um. Der Maximalwert der Y-Achse soll abhängig vom Wertebereich der Y-Werte eine "schöne" Zahl sein. Ich vermute für Dich ist eine "schöne" Zahl: 1,2,3,5 bzw. 10,20,30,50 usw. Die Teilung der Y-Achse ergibt sich direkt aus dem Maximalwert.
1: 0,1/0,2/0,3/0,4/0,5/0,6/0,7/0,8/0,9/1,0
2: 0,2/../1,8/2,0
3: 1/2/3
5: 1/2/3/4/5
Oder so ähnlich. Das bleibt Dir überlassen.
Falls ich Dich da dann also richtig verstanden habe, geht es also lediglich darum den Maximalwert der Y-Werte in eine der vier Kategorien einzuordnen. Dazu würde ich Max(Y) zunächst normieren, also auf das Intervall [0..10[ herunter rechnen.

Delphi-Quellcode:

var
  NPotenz: Integer;
  YDiv: Double;
  YResult: Double; 
begin
  NPotenz := trunc(Log10(YMax));
  YDiv:= IntPower(10, NPotenz);
  YNorm := trunc(YMax / YDiv);
end;

Jetzt mache ich die Fallunterscheidung für die "schöne" Zahl:

Delphi-Quellcode:

    if YNorm<=3
    then
      YResult := YNorm
    else
    if YNorm<=5
    then
      YResult := 5
    else
      YResult := 10;

Und nun muss ich lediglich die korrekte Potenz wieder herstellen

  YResult := YResult * YDiv; Vielleicht gibt es jetzt noch irgendwelche Rundungsprobleme usw. Aber das soll hier ja auch nur einen möglichen Lösungsweg skizzieren und keine fertige Lösung sein.

[Harry Stahl]

Die von Samso vorgeschlagene Lösung sieht schon sehr gut aus. Habe das mal in den Source gepackt, der sieht nun so aus:

Delphi-Quellcode:

procedure TForm82.Button1Click(Sender: TObject);
var
  L: Integer;
  Val, MaxVal: Extended;

  NPotenz: Integer;
  YDiv, YNorm: Double;
  YResult: Double;

begin
  with chart1 do begin
    series1.clear;
    title.Text.Text := 'Monatliche Umsätze im Jahr 2017';

    Maxval := 0;

    sgUmsatz.cells[0, 0] := 'Monat';
    sgUmsatz.cells[1,0] := 'Betrag';
    sgUmsatz.cells[2,0] := 'Wert Y-Achse';

    for L := 1 to 12 do begin
      sgUmsatz.cells[0, L] := FormatDateTime ('mmm', StrToDate ('01.01.2017') + ((L-1) * 33));
      Val := Random (TButton(sender).tag);
      MaxVal := max (MaxVal, val);
      sgUmsatz.cells[1, L] := Val.ToString;
      series1.Add (StrToFloat (sgUmsatz.cells[1, L]), sgUmsatz.cells[0,L], clGreen);
    end;
  end;

  NPotenz := trunc(Log10(MaxVal));
  YDiv:= IntPower(10, NPotenz);
  YNorm := trunc(MaxVal / YDiv);

  if YNorm<=3
    then
      YResult := YNorm
    else
    if YNorm<=5
    then
      YResult := 5
    else
      YResult := 10;

  // Soll hier nun die selbst errechneten Werte für die Y-Achse ausgeben
  for L := 1 to 10 do begin
    sgUmsatz.cells[2,L] := (L * YDiv).tostring;
  end;

  // Nicht benötigt, oder?
  YResult := YResult * YDiv;
end;

Eigentlich brauche ich doch nur den YDiv-Wert, oder?

Siehe neuer Screenshot und angepasstes Demo im Anhang.

[samso]

Da liegt ein Missverständnis vor. YDiv hat nichts mit der Einteilung der Y-Achse zu tun. Eventuell komme ich heute Abend dazu, mir Dein Demoprogramm mal vorzunehmen.

[samso]

Ist Dein Ziel eine Nachbildung von TChart? Der Maximalwert der Y-Achse ist dort daran orientiert, dass oberhalb der Säule mit dem maximalen Umsatz noch genug Platz sein muss um das zugehörige Monats-Label anzubringen. Da muss dann natürlich die Schriftgröße des Labels, die Größe der Zeichenfläche usw. in der Berechnung berücksichtigt werden.