Algorithmus - Zahlen auf Display zentrieren

[Crocotronic]

Zitat von BUG:

Ich nehme mal an, das die Zahlen längere Zeit angezeigt werden (Wartenschlangennummer, oÄ.).

Richtig!

Zitat von Furtbichler:

Schau dir mal Zahlen aus Fixed-Spaced Fonts (Courier z.B.) die sind so designed und es sieht gut aus.
Allerdings kann ich dein ästhetisches Naserümpfen nachvollziehen, allerdings zappelt die Anzeige dann hin und her (fände ich persönlich grauenvoll).

Ich habe nur 12 Fonts zur Verfügung, die schon auf dem Display gespeichert sind. Und wie schon gesagt, sind diese bei maximaler Größe viel zu verpixelt. Deshalb musste ich aus jeder Zahl ein eigenes Bitmap machen.

Das mit dem Kerning schau ich mir mal genauer an...

[Klaus01]

nunja - verpixelt, da kommt es auch immer auf die Entfernung die Betrachter zum Display hat an.

Grüße
Klaus

[Perlsau]

Zitat von Crocotronic:

ich suche nach einem Algorythmus, der mir 1,2 und 3-Stellige Zahlen auf einem Display zentriert.

Ist im Grunde nicht schwer. Als Beispiel hab ich eine kleine Testanwendung angehängt (Delphi 2009).

[Furtbichler]

Zitat:

Deshalb musste ich aus jeder Zahl ein eigenes Bitmap machen. Das mit dem Kerning schau ich mir mal genauer an...

Na dann hast Du doch die maximale Freiheit. Stichwort Kerning: Fixed Space Fonts (Courier z.B.) benötigen kein Kerning Du kannst Dir ja die Bitmaps so wie eine Consolas, Letter Gothic oder Lucida Sans Typewriter erstellen bzw. von Windows sogar rendern lassen: Einfach in 150pt (oder was weiss ich) in Word, Screenshot => Bitmap => Fertig.

Hier mal mein bescheidener Beitrag (Zahl wird von rechts nach links gezeichnet). Die Kerninginfo steht im Array 'KerningCorrection'.
Die '1' hinter einer '0' wird um 10 Pixel, die '7' hinter einer '0' um 6 pixel nach links verschoben,

Delphi-Quellcode:

Const
  KerningCorrection : Array [0..9, 0..9] Of Integer = (
       {  0   1   2   3   4   5   6   7   8   9}
   {0} (  0,-10,  0,  0,  0,  0,  0, -6,  0,  0),
   {1} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {2} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {3} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {4} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {5} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {6} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {7} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {8} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0),
   {9} (  0,  0,  0,  0,  0,  0,  0,  0,  0,  0)
);
Function CalcNumberWidth (Number : Integer) : Integer;
Var
  Digit, DigitToTheRight : Integer;

Begin
  Result := 0;
  DigitToTheRight := -1;
  Repeat
    Digit := Number mod 10;
    Number := Number div 10;
    Result := Result + GetDigitWidth(Digit,false) + GetKerningCorrection (Digit, DigitToTheRight);
    DigitToTheRight := Digit;
  Until Number=0;
End;

Procedure DrawNumberAt (LeftPos, Number : Integer);
Var
  Digit, DigitToTheRight : Integer;

Begin
  Repeat
    Digit := Number mod 10;
    Number := Number div 10;
    LeftPos := LeftPos -  GetDigitWidth(Digit,false) + GetKerningCorrection (Digit, DigitToTheRight);
    DigitToTheRight := Digit;
    DrawDigitAt(LeftPos, Digit);
  Until Number=0;
End;

Function GetKerningCorrection (Digit, DigitToTheRight : Integer) : Integer;
// > 0 add spacing, < 0 reduce spacing
Begin
  If DigitToTheRight = -1 then 
    result := 0
  else 
    result := AdditionalSpacing[Digit, DigitToTheRight];
End;

Procedure DisplayNumber (Number : Integer; Alignment : TAlignment);
Const
  DisplayWidth = 320;
Var
  NumberWidth, LeftPos, i : Integer;

Begin
  ClientConnect;
  Try
    NumberWidth := CalcNumberWidth(Number);
    case Alignment of
      taLeftAlignment:
        LeftPos := DisplayWidth - NumberWidth;
      taCenter:
        LeftPos := (DisplayWidth + NumberWidth) div 2;
      taRightAligment
        LeftPos := DisplayWidth;
    end;

    DrawNumberAt(LeftPos, Number);
  Finally
    ClientDisconnect
  End
End;

Ungetestet.

[Crocotronic]

Wow, funktioniert auf anhieb! Dafür schon mal vielen vielen Dank!
Was noch nicht ganz funktioniert ist, dass die Kerning Correction beim zentrieren mit einberechnet wird (siehe Bild).

Viele Grüße
Croco

[Furtbichler]

Hast Du denn eine Kerning-Korrektur für '01' oder nur für '10'. Bei der '1' ist links ein leerer Raum, und denn füllt man mit einem kleinen Teil des rechten Rands der '0'.

Ich würde eher sagen, das der Parameter für 'Alignment' auf taLeftAlignment steht bzw. der Wert von 'LeftPos' falsch ist.

Vor dem Aufruf von DrawNumberAt muss er den rechten Rand des rechten Bitmaps (bei dir die '0') beschreiben. Die Breite sollte korrekt errechnet sein...

Haaalt! Da ist ein kleiner Fehler.

Delphi-Quellcode:

Procedure DrawNumberAt (LeftPos, Number : Integer);
Var
   Digit, DigitToTheRight : Integer;

Begin
   DigitToTheRight := -1; // <<<<<< FEHLT!
   Repeat
...

[Crocotronic]

Zitat von Furtbichler:

Hast Du denn eine Kerning-Korrektur für '01' oder nur für '10'. Bei der '1' ist links ein leerer Raum, und denn füllt man mit einem kleinen Teil des rechten Rands der '0'.
Ich würde eher sagen, das der Parameter für 'Alignment' auf taLeftAlignment steht bzw. der Wert von 'LeftPos' falsch ist.

Also ich hab die Kerning-Korrektur bei 1 für 1 auf -20 stehen
{1} ( 0, -20, 0, 0, 0, 0, 0, 0, 0, 0), Das Alignment steht auf taCenter. Es wird auch zentriert, wenn ich die -20 durch eine 0 ersetze.

Zitat von Furtbichler:

Haaalt! Da ist ein kleiner Fehler.

Delphi-Quellcode:

Procedure DrawNumberAt (LeftPos, Number : Integer);
Var
   Digit, DigitToTheRight : Integer;

Begin
   DigitToTheRight := -1; // <<<<<< FEHLT!
   Repeat
...

Tatsächlich! Ist aber nicht der Fehler für das falsch Zentrierte.

[Crocotronic]

Habs! Abs ist das Stichwort

Delphi-Quellcode:

function TWartezeit.CalcNumberWidth(aNumber: integer): integer;
var Digit, DigitToTheRight : Integer;
begin
 Result:= 0;
 DigitToTheRight:= -1;
 repeat
  Digit:= aNumber mod 10;
  aNumber:= aNumber div 10;
  Result:= Result + GetDigitWidth(Digit,false) + Abs(GetKerningCorrection(Digit, DigitToTheRight)); // <- hier würde sonst die Breite verringert werden
  DigitToTheRight:= Digit;
 until aNumber=0;
end;

[Furtbichler]

Nein nein. Steht eine '1' rechts von einer '0', soll die '0' etwas nach links rutschen. Das geschieht, indem die '0' dann etwas schmaler wird. Vielleicht habe ich die Vorzeichen in der KerningCorrection-Matrix vertauscht. Ich hatte es ja nicht getestet.