Graphic-library OHNE Arduino mit Texten und Farbkorrektur

[Robert B. (robertb)]

Hallo!

Ich suche eine Grafik Bibliothek ähnlich der Adafruit GFX, welche aber 
im Idealfall auf Plain-C aufsetzt und keine weiteren (Arduino) Libraries 
benötigt.

Oder andersrum: Ich habe auf einer recht unüblichen MCU Plattform eine 
bereits per DMA und SPI sehr effiziente Ansteuerung von APA102 LEDs mit 
einem einwandfrei nutzbaren Framebuffer.

Interface wäre also quasi "SetPixel(x, y, r, g, b, [brightness])". Jetzt 
suche ich "upper-layer" Funktionen für Kreise, Linien, ggf. 
Farbkorrekturtabellen und am liebsten die Adafruit GFX Fonts.

Danke!

Grüße
Robert

[Lukas W. (lukas_we)]

Probiere es mal mit LVGL

[Johannes S. (Gast)]

Die AdafruitGFX ist nicht sehr Arduino spezifisch und kann auch für 
andere Plattformen umgebaut werden. Und C++ unterstützt gerade die 
Implementierung für verschiedenste Grafik Controller, inklusive LED 
Matrizen.

Lukas W. schrieb:
> Probiere es mal mit LVGL

da liegt der Fokus aber auf dem GUI level, einfache Zeichenfunktionen 
sind da eher aufwändig weil die wieder extra Speicher für den 
Zeichenbereich brauchen.

[Ralph S. (jjflash)]

Robert B. schrieb:
> Funktionen für Kreise, Linien, ggf.

Bresenham (Linie) aus Wikipedia:

void line(int x0, int y0, int x1, int y1)
{
  int dx =  abs(x1-x0), sx = x0<x1 ? 1 : -1;
  int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
  int err = dx+dy, e2; /* error value e_xy */

  while (1) {
    setPixel(x0,y0);
    if (x0==x1 && y0==y1) break;
    e2 = 2*err;
    if (e2 > dy) { err += dy; x0 += sx; } /* e_xy+e_x > 0 */
    if (e2 < dx) { err += dx; y0 += sy; } /* e_xy+e_y < 0 */
  }
}

Bresenham (Ellipse) aus Wikipedia:

void ellipse(int xm, int ym, int a, int b)
{
   int dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
   long a2 = a*a, b2 = b*b;
   long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

   do {
       setPixel(xm+dx, ym+dy); /* I. Quadrant */
       setPixel(xm-dx, ym+dy); /* II. Quadrant */
       setPixel(xm-dx, ym-dy); /* III. Quadrant */
       setPixel(xm+dx, ym-dy); /* IV. Quadrant */

       e2 = 2*err;
       if (e2 <  (2*dx+1)*b2) { dx++; err += (2*dx+1)*b2; }
       if (e2 > -(2*dy-1)*a2) { dy--; err -= (2*dy-1)*a2; }
   } while (dy >= 0);

   while (dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
       setPixel(xm+dx, ym); /* -> Spitze der Ellipse vollenden */
       setPixel(xm-dx, ym);
   }
}

void circle(int xm, int ym, int r)
{
  ellipse(xm, ym, r, r);
}

Funktionen kann man evtl. Farben mit übergeben und den setpixel in den 
Funktionen dann mitgeben.

Ab dem Moment, bei dem es schon ein funktionierendes Setpixel oder 
Putpixel schon gibt, gibt es zig Funktionen im Netz verfügbar, die von 
der Hardware unabhängig sind.

[Waldfee (Gast)]

LVGL ist für so was ideal. Ist in Plain C, brauch nur SetPixel um ein 
Bild aufzubauen. Habe es selbst auf meiner Smartwat laufen. Als 
Vergleich, ein ESP32 packt locker 30FPS