C -> Zeichen aus Font suchen / rechnen?!

[Jan H. (janiiix3)]

Ist in der Funktion ein Denkfehler?
Die Zeichen die dabei raus kommen sind verschoben oder überhaupt nicht 
zu erkennen. Ist bei meiner Berechnung etwas falsch?
Kann sich das mal bitte jemand anschauen?!

/*  Wird benoetigt um Fontparameter zu berechnen
*/
static inline Font_t GetPixelStart(uint8_t c, Font_t Font, const uint8_t __flash *ptrFont)
{
  #define OFFSET_SETTING_INFOS  8
  
  uint8_t charNum = 0;
  
  Font.uiCharWidth  = ptrFont[(c-Font.ptrFont[FONT_FIRST_CHAR])+OFFSET_SETTING_INFOS]; // Breite des Zeichens
  Font.uiIndexBegin  = Font.ptrFont[FONT_PIXEL_BEGIN]; // Offset (ab hier beginnen die Pixel Daten)
  
  if ( Font.ptrFont[FONT_FIXED_OR_VARIABLE] == 1 ) // Fonts mit fester Breite
  {
    for(  ; charNum <= (c - Font.ptrFont[FONT_FIRST_CHAR])-1 ; charNum++)
    {
      Font.uiIndexBegin += (Font.ptrFont[FONT_WIDTH] * ((Font.ptrFont[FONT_HEIGHT] / 8)+1)); // Font breite berechnen
    }
  }
  else if ( Font.ptrFont[FONT_FIXED_OR_VARIABLE] == 0)
  {
    for(  ; charNum <= (c - Font.ptrFont[FONT_FIRST_CHAR])-1 ; charNum++)
    {
      Font.uiIndexBegin += (ptrFont[charNum + OFFSET_SETTING_INFOS] * 2 );
    }
  }
  
  return Font;
}

P.S
Anbei mal ein Beispiel Font.

Mfg

[Stefan F. (Gast)]

Ohne den vollständigen Quelltext ist das schwer zu sagen. Die Werte der 
allermeisten Konstanten sind unbekannt und man muss raten, wie du die 
Funktion verwendest.

[Jan H. (janiiix3)]

Stefanus F. schrieb:
> Ohne den vollständigen Quelltext ist das schwer zu sagen. Die
> Werte der
> allermeisten Konstanten sind unbekannt und man muss raten, wie du die
> Funktion verwendest.
Da hast Du vollkommend recht. Habe noch was vergessen..

enum Font_Struct
{
  FONT_BEGIN,
  FONT_END,
  FONT_WIDTH,
  FONT_HEIGHT,
  FONT_FIRST_CHAR,
  FONT_CHAR_COUNT
  FONT_BEGIN_PIXEL,
  FONT_FIXED_OR_VARIABLE,
};

Das sind eigentlich nur die Indexnummern für die Werte aus dem "Font 
Array".
Die Funktion rufe ich auch, bevor ich ein Zeichen brauche, in der 
Struktur die zurückgegeben wird, sollte dann der Start der Pixel 
Informationen und deren einzelnen Breiten stehen..

[Stefan F. (Gast)]

Wie rufst du die Funktion auf?

Annahme:
Font ist ein zunächst leeres Objekt, dass die Funktion befüllen soll.
ptrFont ist ein Zeiger auf die Font Daten im Header.

Das passt aber nicht zu deinem Code, denn da liest du munter 
wechselweise von ptrFont und Font.ptrFont. Frage: Wo sind die Font Daten 
(input). In ptrFont oder in Font.ptrFont?

[Jan H. (janiiix3)]

Stefanus F. schrieb:
> Wie rufst du die Funktion auf?
>
> Annahme:
> Font ist ein zunächst leeres Objekt, dass die Funktion befüllen soll.
> ptrFont ist ein Zeiger auf die Font Daten im Header.
>
> Das passt aber nicht zu deinem Code, denn da liest du munter
> wechselweise von ptrFont und Font. Frage: Wo sind die Font Daten
> (input). In ptrFont oder in Font?

Stimmt. Sehe ich gerade.

Jan H. schrieb:
> Font.uiCharWidth  =
> ptrFont[(c-Font.ptrFont[FONT_FIRST_CHAR])+OFFSET_SETTING_INFOS]; //
> Breite des Zeichens
>   Font.uiIndexBegin  = Font.ptrFont[FONT_PIXEL_BEGIN]; // Offset (ab
> hier beginnen die Pixel Daten)
Du meinst mit Sicherheit das? Ist ein wenig sinnlos, muss ich ändern. 
Jedoch ist beides eine Referenz auf den Zeichensatz.

[Stefan F. (Gast)]

Jan H. schrieb:
> Du meinst mit Sicherheit das?

Ja genau, das.

Du kannst das Ganze ja mal in einem Debugger oder Simulator durchsteppen 
und dabei schauen, ob die Berechnungen die erwarteten Werte ergeben. 
Oder du gibst sie zum Debugging auf einem seriellen Port aus.

[Jan H. (janiiix3)]

Stefanus F. schrieb:
> Jan H. schrieb:
>> Du meinst mit Sicherheit das?
>
> Ja genau, das.
>
> Du kannst das Ganze ja mal in einem Debugger oder Simulator durchsteppen
> und dabei schauen, ob die Berechnungen die erwarteten Werte ergeben.
> Oder du gibst sie zum Debugging auf einem seriellen Port aus.

Habe es angepasst.

static inline Font_t GetPixelStart(uint8_t c, Font_t Font, const uint8_t __flash *ptrFont)
{
  #define OFFSET_SETTING_INFOS  8
  
  uint8_t charNum = 0;
  
  Font.uiCharWidth  = ptrFont[ ( c - Font.ptrFont[_FONT_FIRST_CHAR] ) + OFFSET_SETTING_INFOS ]; // Breite des Zeichens
  Font.uiIndexBegin  = ptrFont[_FONT_PIXEL_BEGIN]; // Offset (ab hier beginnen die Pixel Daten)
  
  if ( Font.ptrFont[_FONT_FIXED_OR_VARIABLE] == 1 ) // Fonts mit fester Breite
  {
    for(  ; charNum <= ( c - Font.ptrFont[_FONT_FIRST_CHAR] ) - 1 ; charNum++ )
    {
      Font.uiIndexBegin += ( Font.ptrFont[_FONT_WIDTH] * ( ( Font.ptrFont[_FONT_HEIGHT] / 8 ) + 1 ) ); // Font breite berechnen
    }
  }
  else if ( Font.ptrFont[_FONT_FIXED_OR_VARIABLE] == 0)
  {
    for(  ; charNum <= ( c - Font.ptrFont[_FONT_FIRST_CHAR] ) - 1 ; charNum++ )
    {
      Font.uiIndexBegin += (ptrFont[charNum + OFFSET_SETTING_INFOS] * 2 ); // Anstatt *2 schieben wir hier einfach
    }
  }
  
  return Font;
}

[Stefan F. (Gast)]

Jan H. schrieb:
> Habe es angepasst.

Und?

[holger (Gast)]

>Ist in der Funktion ein Denkfehler?
>Die Zeichen die dabei raus kommen sind verschoben oder überhaupt nicht
>zu erkennen. Ist bei meiner Berechnung etwas falsch?

Ja, deine Berechnung ist falsch. Bei deiner Berechnung der Bytes
pro Zeichen kommt immer der gleiche Wert raus. Die Anzahl der Bytes
pro Zeichen ist aber nicht immer gleich. Du wirst schon die Werte
unter  // char widths auswerten müssen statt Font.ptrFont[FONT_WIDTH].

[holger (Gast)]

Ach vergiss meinen Post. Hatte mir den unteren Teil nicht angesehen;)

[Jan H. (janiiix3)]

holger schrieb:
> Ach vergiss meinen Post. Hatte mir den unteren Teil nicht angesehen;)

Wollte schon sagen.. :D

[holger (Gast)]

Neuer Versuch:

Font.uiIndexBegin += (ptrFont[charNum + OFFSET_SETTING_INFOS] * 2 )

Die 2 da hinten. Für den Courier müsste da eine 4 stehen.
Du berücksichtigst die Höhe des Fonts dort nicht.

[Jan H. (janiiix3)]

holger schrieb:
> Neuer Versuch:
>
> Font.uiIndexBegin += (ptrFont[charNum + OFFSET_SETTING_INFOS] * 2 )
>
> Die 2 da hinten. Für den Courier müsste da eine 4 stehen.
> Du berücksichtigst die Höhe des Fonts dort nicht.
Es geht da wirklich nur um die Weite des Zeichens. Die Höhe ist ja Fix.

[holger (Gast)]

>Es geht da wirklich nur um die Weite des Zeichens. Die Höhe ist ja Fix.

Ja, klar ist die fix. Aber mit der zwei hinten kannst du nur Zeichen
von 9 bis 16 Pixel Höhe auswerten. Die Höhe ist aber 26Pixel.

[Jan H. (janiiix3)]

holger schrieb:
>>Es geht da wirklich nur um die Weite des Zeichens. Die Höhe ist ja Fix.
>
> Ja, klar ist die fix. Aber mit der zwei hinten kannst du nur Zeichen
> von 9 bis 16 Pixel Höhe auswerten. Die Höhe ist aber 26Pixel.
Habs mit "*4" versucht, genau das gleiche.

[Chris (Gast)]

Du lieferst nicht gerade gute Informationen um Dir zu helfen, ist Dir 
das klar?


* Dein "enum Font_Struct" enthält andere Werte als Du im Code benutzt 
(z.B. FONT_BEGIN_PIXEL vs. _FONT_PIXEL_BEGIN)

* Auch in Deinem "angepassten" Code geht weiterhin ptrFont und 
Font.ptrFont munter durcheinander.


Weißt Du eigentlich, wie die Font-Daten organisiert sind?
Anhand des Zeichens 33 (das Ausrufungszeichen) habe ich durch 
ausprobieren herausbekommen, dass die Daten wohl spaltenweise von oben 
nach unten abgelegt sind, das lsb der Bytes ist dabei oben. 
Spaltenwechsel ist immer an einer Bytegrenze, d.h. beim vorliegenden 
Font sind die höherwertigsten 6 Bits jedes vierten Byte "don't care".

Nehmen wir mal an:

#define _FONT_WIDTH             2
#define _FONT_HEIGHT            3
#define _FONT_FIRST_CHAR        4
#define _FONT_PIXEL_BEGIN       6
#define _FONT_FIXED_OR_VARIABLE 7

Anzahl Bytes pro Spalte ist also:

 bytes_per_col = (((ptrFont[_FONT_HEIGHT]-1) / 8) + 1);

Für den Offset musst Du alle Zeichenbreiten vor dem gesuchten addieren.

 
Font.uiIndexBegin = ptrFont[_FONT_PIXEL_BEGIN];
for( charNum=0 ; charNum < (c - ptrFont[_FONT_FIRST_CHAR]) ; charNum++)
  Font.uiIndexBegin += (ptrFont[charNum + OFFSET_SETTING_INFOS] * bytes_per_col );

Bist Du sicher, dass Du die Pixeldaten dann auch richtig ausgegeben 
bekommst, wenn Dir die Routine den Offset richtig berechnet hat? (ich 
hab' da so meine Zweifel... ;-)

[W.S. (Gast)]

Jan H. schrieb:
> Habe es angepasst.

..und es ist nach wie vor zumindest für mich herzlich unleserlich. Was 
willst du mit diesem Code eigentlich bezwecken? Was bedeutet 
"GetPixelStart" und wozu sollte man sowas brauchen?


Also, ich sehe das GANZ anders:

Für ne grafische Darstellung braucht man eine Funktion, die ein 
Textzeichen an einer bestimmten Stelle auf einer grafischen Oberfläche 
(z.B. Display) zeichnen kann. Im Allgemeinen sollte dies in einer Farbe 
möglich sein, die irgendwo vorgegeben ist. Dazu kommt, daß das 
Textzeichen in einem gewünschten Font gezeichnet werden soll. Für das 
Zeichnen von Zeichenketten (Strings) ist es wünschenswert, daß diese 
Funktion die Breite des aktuellen Zeichens zurückliefert. Also sieht so 
eine Funktion erstmal etwa so aus:

int ZeichneChar(char c, int x, int y, irgendwas* Font, int Farbe)
{...

Und diese Funktion soll mit den verschiedensten Fonts zurecht kommen, 
also müssen die Fonts eine gewisse Struktur haben, aus der man möglichst 
leicht ermitteln kann, was da alles an Zeichen vorhanden ist, wie groß 
so ein Zeichen ist, wo der zugehörige Glyph steht und so weiter.
Ich habe das bei meinen Fonts so gehandhabt:

/*  Beschreibung des verwendeten Font-Formates:
 zuerst kommt der Font-Header in folgendem Format: */

#define Fontheadersize 6
struct Fontheader
{ byte Capitals; /* Hoehe der Grossbuchstaben */
  byte Height;   /* Font-Gesamthoehe */
  byte Ascent;   /* Hoehe ueber Null-Linie */
  byte Descent;  /* Tiefe unter Null-Linie */
  char ChMin;    /* kleinstes vorhandenes Zeichen */
  char ChMax;    /* groesstes vorhandenes Zeichen */
};

/* danach kommen unterschiedlich viele Char-Entries.
   eigentlich ist 'Disp' ein 16 bit Offset, aber der
   Font muss bei BigEndian und LittleEndian-CPU's
   gleichermassen funktionieren, deswegen die explizite
   Aufteilung in DispHi und DispLo  */

#define Charentrysize 4
struct CharEntry
{ byte DispHi;   /* Hi vom Displacement ab Fontbeginn */
  byte DispLo;   /* Lo vom Displacement ab Fontbeginn */
  byte dX;       /* Breite in Pixeln */
  byte dY;       /* Hoehe in Pixeln */
};

/* danach kommen die Pixel. Jeder CharEntry (s.o.) zeigt
   auf den Beginn des zu seinem Char gehörigen Bitmusters.
   Jedes Bitmuster beginnt an einem ganzen Byte, aber innerhalb
   geht es je nach Zeichenbreite asynchron zu den Bytegrenzen */

Und die Funktion, die mithilfe eines so aufgebauten Fonts Text auf die 
Glotze schreiben kann geht so (hier für Monochrom):

/***************************************************************
 Zeichnet das Textzeichen im aktuellen Font an der
 angegebenen Stelle und liefert die Breite des Zeichens
 ***************************************************************/
int CgCh_at(int X, int Y, char Ch, const char* Font, int mode)
{ struct Fontheader* FHE;
  struct CharEntry*  CHE;
  byte*  Pix;
  long   top, bott;
  dword  w;
  dword  pixw;
  long   dX;

  top   = Y;

/* aus dem Font die Breite, Höhe und Pixel entnehmen */
  FHE = (struct Fontheader*) Font;
  if ((Ch < FHE->ChMin)||(Ch > FHE->ChMax)) Ch = 0;
  else Ch = Ch - FHE->ChMin;
  CHE = (struct CharEntry*) ((long) FHE + Fontheadersize);
  CHE += Ch;
  w   = (CHE->DispHi << 8) | CHE->DispLo;
  Pix = (byte*) ((long) FHE + w);

/* bott setzen */
  bott = top + CHE->dY;
  if (bott>lcdhoehe-1) bott = lcdhoehe-1;

/* die Register sind jetzt:
  bott = zeigt jetzt hinter die unterste zu schreibende Zeile des Zeichens
  Pix  = Zeiger auf zugehörige Pixel im Font
  FHE, CHE haben sich (fast) erledigt
  Nun die ersten Fontpixel und die Maske laden
 */
  pixw = *Pix++;
  w = 1;

/* Y - Zeichen-Zyklus */
  while (top < bott)
  {   /* X - Zeichen-Zyklus */
      dX  = 0;
      while (dX < CHE->dX)   /* Zeichenbreite in Pixeln */
      { if (pixw & w) CgPixel_at (X+dX, top, mode);
  ++dX;
        w = (w << 1) & 0xFF;
        if (!w)
        {   pixw = *Pix++;
            w = 1;
  }
      }
      ++top;
  }
  return CHE->dX;
}

So geht das - und so ein Font ist von hause aus proportional, hat also 
je nach Zeichen unterschiedliche Zeichenbreiten. Natürlich kann man 
damit auch Courier12 machen, indem man die Zeichenbreite eben beim 
Fontmachen konstant läßt. Ebenso kann man damit auch monochrome Icons 
und Piktogramme machen, die Schreibfunktion kommt mit allen Formaten 
zurecht, solange der Font korrekt ist.

Den ganzen Krempel hatte ich hier schon mal gepostet, ebenso dazu einen 
kleinen Font-Compiler.

W.S.

[W.S. (Gast)]

Nachtrag: damit du dir das besser vorstellen kannst.

W.S.

[Jan H. (janiiix3)]

Erstmal danke euch beiden für die super Erklärung.

Wenn ich den Index richtig berechnet haben sollte, bin ich bis jetzt 
soweit mit der Ausgabefunktion.

Ich vermute mal das es hier auch noch einige Sachen gibt die fehlerhaft 
sind.

void Ssd1306PutChar( char c , int16_t y , int16_t x )
{  
  Font = calcFontStart( c , Font , Font.ptrFont );  
  
  /* Höhe des Zeichens in "Pages" aufgeteilt ( Page = 8 Pixel )
  */
  uint8_t uiPages = ( ( Font.ptrFont[3] / 8 ) + 1);
  
  uint16_t uiLastWidth = 0;
  
  for ( uint8_t uiActualPage = 0 ; uiActualPage < uiPages ; uiActualPage++ )
  {
    for ( uint8_t uiActualWidth = 0 ; uiActualWidth < Font.uiCharWidth ; uiActualWidth++ )
    {
      for ( uint8_t uiPixel = 0 ; uiPixel < 8 ; uiPixel++ )
      {
        if ( Font.ptrFont[Font.uiIndexBegin + ( uiLastWidth + uiActualWidth ) ] & 1<<uiPixel )
        {
          if ( uiActualPage == 0 )
          {
            Ssd1306DrawPixel( ( y + uiPixel ) , ( x + uiActualWidth ) );
          }else
          {
            Ssd1306DrawPixel( ( y + uiPixel ) + ( uiActualPage * 128 ) , ( x + uiActualWidth ) + ( uiActualPage * 128 ) );            
          }
        }else
        {
          if ( uiActualPage == 0 )
          {
            Ssd1306ClearPixel( ( y + uiPixel ) , ( x + uiActualWidth ) );
          }else
          {
            Ssd1306ClearPixel( ( y + uiPixel ) + ( uiActualPage * 128 ) , ( x + uiActualWidth ) + ( uiActualPage * 128 ) );
          }
        }        
      }
    }uiLastWidth+=Font.uiCharWidth;
  }
}

[Stefan F. (Gast)]

Ich würde hier nicht einzelne Pixel ausgeben, sondern möglichst größere 
Blöcke von Bytes. Sonst dauert das ja "ewig". Kannst du nicht direkt in 
den Pufferspeicher schreiben, anstatt den Umweg über Ssd1306DrawPixel() 
zu nehmen?

[leo (Gast)]

W.S. schrieb:
> int ZeichneChar(char c, int x, int y, irgendwas* Font, int Farbe)
> {...

Kaum. Im allgemeinen will man nicht bei jedem Zeichen Font oder Farbe 
wechseln.
Das Interface stimmt nicht. Font und Farbe stellt man einmal für 
zukünftige Ausgaben ein.

leo

[Jan H. (janiiix3)]

Stefanus F. schrieb:
> Ich würde hier nicht einzelne Pixel ausgeben, sondern möglichst größere
> Blöcke von Bytes. Sonst dauert das ja "ewig". Kannst du nicht direkt in
> den Pufferspeicher schreiben, anstatt den Umweg über Ssd1306DrawPixel()
> zu nehmen?

Klar kann man das. Wollte aber auch mal die Pixel Variante versuchen und 
verstehen.

Habe es ja vorher so gehabt.

[Stefan F. (Gast)]

Jan H. schrieb:
> Wollte aber auch mal die Pixel Variante versuchen und verstehen.

Bei mir sind die Bytes im Font genau so ausgerichtet, wie im Speicher 
des Display (Jedes Byte stellt 8 Pixel dar, die untereinander stehen, 
also ein vertikale Linie ergeben). Wenn die Zeile Text "zufällig" genau 
passend ausgerichtet ist, kann ich einfach die Bytes aus dem Font 1:1 in 
den Pufferspeicher übertragen. Wenn nicht, teile ich den Text in obere 
und untere Hälfte auf, bevor ich die beiden halben Zeilen in den 
Pufferspeicher übertrage.

Aber die Sache mit dem Aufteilen hätte ich mir schenken können. Da bin 
ich übers Ziel hinaus geschossen (von wegen Eierlegende Wollmilchsau). 
In der Praxis genügt es, acht Zeilen mit fester y-Position zu haben. Wer 
will schon Text dazwischen ausgeben?

[Jan H. (janiiix3)]

Habe jetzt die Routine für das suchen der Pixeldaten erneuert.

Font_t GetFont( uint8_t c )
{
  Font_t Font;
  
  Font.uiWidht       = 0;
  Font.uiHeight       = GetFontHeight( _ptrFont );
  uint8_t  uiHeightInBytes = ( Font.uiHeight + 7 ) / 8; /* calculates height in rounded up bytes */

  uint8_t uiFirstChar = _ptrFont[ _FONT_FIRST_CHAR ];
  uint8_t uiCharCount = _ptrFont[ _FONT_CHAR_COUNT ];

  Font.uiIndex = 0;
  
  c -= uiFirstChar;

  if ( IsFixedWidthFont( _ptrFont ) ) 
  {
    Font.uiWidht = _ptrFont[ _FONT_FIXED_WIDTH ];
    Font.uiIndex = ( c * uiHeightInBytes * Font.uiWidht + _FONT_WIDTH_TABLE );
  }else 
  {

    for (uint8_t i = 0; i < c; i++) 
    {
      Font.uiIndex += _ptrFont[ _FONT_WIDTH_TABLE + i ];
    }

    Font.uiIndex = ( Font.uiIndex * uiHeightInBytes + uiCharCount + _FONT_WIDTH_TABLE );

    Font.uiWidht = _ptrFont[ _FONT_WIDTH_TABLE + c ];
  }
  
  return Font;
}

Damit bekomme ich jetzt definitiv den richtigen Anfang meines gesuchten 
Zeichens, des Weiteren scheibe ich die ganzen Informationen wie ( Höhe, 
Breite , Start ) in eine Struktur.

Der Zeiger zu dem Array, ist jetzt nicht mehr Teil der Struktur. Der 
Zeiger wurde global ausgelagert.

Wenn das mit dem Zeichen der einzelnen Pixel sauber klappt, werde ich 
deine Lösung auch vorziehen. Wie Du schon sagtest, frisst das um längen 
nicht so viele Ressourcen.

Was kann ich an der Ausgabefunktion noch verändern / verbessern?
Diese soll die Pixel in ein "VRAM" schreiben, dass später an einer 
anderen Stelle, wenn es fertig befüllt ist, übertragen werden.

Zeichen in den VRAM schreiben ->

void Ssd1306PutChar( char c , int16_t y , int16_t x )
{  
  Font = GetFont( c );
  
  /* Höhe des Zeichens in "Pages" aufgeteilt ( Page = 8 Pixel )
  */
  uint8_t uiPages = ( ( _ptrFont[3] / 8 ) + 1);
  
  uint16_t uiLastWidth = 0;
  
  for ( uint8_t uiActualPage = 0 ; uiActualPage < uiPages ; uiActualPage++ )
  {
    for ( uint8_t uiActualWidth = 0 ; uiActualWidth < Font.uiWidht ; uiActualWidth++ )
    {
      for ( uint8_t uiPixel = 0 ; uiPixel < 8 ; uiPixel++ )
      {
        if ( _ptrFont[Font.uiIndex + ( uiLastWidth + uiActualWidth ) ] & 1<<uiPixel )
        {
          if ( uiActualPage == 0 )
          {
            Ssd1306DrawPixel( ( y + uiPixel ) , ( x + uiActualWidth ) );
          }else
          {
            Ssd1306DrawPixel( ( y + uiPixel ) + ( uiActualPage * 128 ) , ( x + uiActualWidth ) + ( uiActualPage * 128 ) );            
          }
        }else
        {
          if ( uiActualPage == 0 )
          {
            Ssd1306ClearPixel( ( y + uiPixel ) , ( x + uiActualWidth ) );
          }else
          {
            Ssd1306ClearPixel( ( y + uiPixel ) + ( uiActualPage * 128 ) , ( x + uiActualWidth ) + ( uiActualPage * 128 ) );
          }
        }        
      }
    }uiLastWidth+=Font.uiWidht;
  }
}

Pixel verarbeiten und an richtige Stelle in den VRAM malen ->

void Ssd1306DrawPixel( int16_t x , int16_t y )
{
   DisplayRam[ y + ( x / 8 ) * SSD1306_LCD_Width ] |=  ( 1 << ( x & 7 ) );
}