Aruco vs Apriltag condizioni reali

Aggiornamento:

Dopo aver provato un po' di tutto per correggere i dati ho scoperto che le immagini originali non sono state riprese in modo corretto. La camera satura in alcuni condizioni di luce come si vede dai due esempi sottostanti rendendo inutile l'elaborazione

Prova comparativa per misuare distanze tramite April ed Aruco tag in condizioni reali 

Lo scopo e' quello di verificare la ripetibilita' delle misure di distanza mediante tag a condizioni di luce variabile e per questo sono state effettuate misure con i tag in posizione stazionaria

E' stata impiegata una camera di sorveglianza a fuoco fisso con acquisizione ogni 10 minuti anche di notte grazie all'illuminazione ad infrarossi

I tag sono stati di dimensione di 25 cm in formato 4x4 per Aruco e 36h11 per gli Apriltag

Per determinare la distanza sono state impiegate le librerie OpenCV su Python per agli Aruco Tags mentre la libreria Apriltags3 in C++

in generale gli Apriltag risultano meglio individuabili rispetto agli Aruco tag. Di 430 immagini totali gli Apriltags sono stati individuati al 99% ad una distanza di 6 m mentre gli Aruco tag hanno prestazioni simili ma solo sulla breve distanza (4 m)

Aruco

l'elaborazione dei tag aruco indica che l'algoritmo genera molti outliers che possono essere facilmente separati dai dati corretti

Provando a smussare i dati con una media mobile a finetra oraria la situazione non migliora e si osserva un comportamento legato all'illuminazione che si ritrovera' anche dopo con gli April Tags 

Apriltag

Dall'analisi dei grafici si vede che le condizioni di illuminazione condizionano fortemente la misura della distanza mediante Apriltag. Le misure piu' stabili sono di notte quando e' attiva l'illuminazione dei led ad infrarossi

Rispetto ad Aruco ci sono molti meno outliers ed i dati sono meno rumorosi

In queste condizioni e' stato registrato un errore di standard devitation pari a 0.96% della distanza per il tag a 6.5m e dell'1% per il tag a 10 m

Se si plottano i dati a parita' di ora del giorno si vede ancora piu' chiaramente come la presenza di ombra influenza il dato di distanza

Se si fa la differenza tra le due curve l'errore scende al 0.18%

Un sistema per rimuovere l'effetto dell'illuminazione e' di correlare i dati dei due tag (sono vicini quindi sono illuminati in modo comparabile)

Per cercare di risolvere il problema delle differenti illuminazione ho provato ad elaborare le immagini mediante l'algoritmo presentato in questo articolo (Illumination Invariant Imaging: Applications in Robust Vision-based Localisation, Mapping and Classification for Autonomous Vehicles)

In estrema sintesi l'algoritmo appiattisce una immagine RGB e cerca di annullare gli effetti di differente illuminaizone (questo algoritmo funziona solo sulle immagini diurne perche' la camera di notte acquisisce a scala di grigi)

Per le elaborazioni ho usato questo progetto su Github.  (ho dovuto fare una leggere modifica perche' le immagini della camera avevano dei valori zero che ovviamente non potevano essere usati in un logaritmo)

import cv2

import numpy as np

import os

from argparse import ArgumentParser

from multiprocessing import Pool

ROBOTCAR_ALPHA = 0.4642

def transform(im):

# Assumes image is RGB-ordered

image = cv2.imread(read_dir + "/" + im, cv2.IMREAD_UNCHANGED)

r, g, b = image[:, :, 0], image[:, :, 1], image[:, :, 2]

// per eliminare gli eventuali zeri dalla matrice

r = np.where(r==0, 0.1, r)

g = np.where(g==0, 0.1, g)

b = np.where(b==0, 0.1, b)

ii_image = 0.5 + np.log(g) - ROBOTCAR_ALPHA*np.log(b) - (1-ROBOTCAR_ALPHA)*np.log(r)

# Lastly, convert from float to uint8 space

max_ii = np.max(ii_image)

min_ii = np.min(ii_image)

uii = np.uint8((ii_image - min_ii) * 256 / (max_ii - min_ii))

ii_name = write_dir + "/" + im

cv2.imwrite(ii_name, uii)

return ii_image

def transform_loop(directory):

image_names = os.listdir(directory)

# Spawn 4 worker processes to transform in parallel

p = Pool(4)

p.map(transform, image_names)

if __name__ == '__main__':

parser = ArgumentParser(

description=

'Transform images in a directory into lighting invariant color space')

parser.add_argument('--read-dir', action="store", type=str, required=True)

parser.add_argument('--write-dir', action="store", type=str, required=True)

args = parser.parse_args()

global read_dir, write_dir

read_dir = args.read_dir

write_dir = args.write_dir

transform_loop(read_dir)

dopo l'applicazione della elaborazione l'algoritmo di riconoscimento dei tag risulta molto piu' in difficolta' nel riconoscere i taf e sono state estratte solo 71 misure di distanza del tag1 e 16 misure del tag 2

Aggiornamento:

Frugando dentro al codice della demo di Apritag3 c'e' un porzione di codice che non puo' mai essere eseguito (c'e' un IF sempre True) e la condizione Falsa e' appunto l'algoritmo di Illumination Invariant 

Basta modificare la riga 156 per esempio aggiungendo un NOT si introduce il calcolo

questi sono i grafici risultanti dopo l'algoritmo. Si e' oersa la ritmicita' dell'illuminazione ma si e' persa anche la capacita' di riconoscere i tag nelle immagini trattate (per il tag 1 circa il 50%, tag2 decisamente peggio)

L'errore percentuale delle standard deviation e' pari a 1.79% per il tag1 e 1.08% per il tag 2

La differenza risiede nel valore del parametro utilizzato nell'elaborazione delle immagini

TI-89 scrittura diretta in memoria video

 Oltre a poter usare un buffer per generare grafica si puo' avere anche la scrittura diretta in memoria video sulla TI-89 puntando all'indirizzo 0x4C00

#define USE_TI89

#define SAVE_SCREEN // Save/Restore LCD Contents

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <kbd.h>

char * reale = (char *) 0x4C00;

int c;

void setpixel(int x, int y)

{

int yc = 30*y;

int xc = (int)floor(x/8);

int xd = 1<<(7-(x % 8));

reale[yc+xc]=xd;

}

void pulisci(void)

{

for (c=0;c<3840;c++)

{

reale[c]=0;

}

}

int _main(void)

{

pulisci();

for (c=0;c<80;c++){

setpixel(c,c);

}

ngetchx();

return 0;

}

Schermo virtuale su TI-89

Una delle cose divertenti con la TI-89 e' di avere il controllo completo dell'hardware con l'accesso diretto alla memoria video

La memoria dello schermo LCD inizia a 0x4C00

Si puo' fare puntare lo schermo virtuale ad una zona di memoria e poterla trattare con i comandi grafici (ogni byte di memoria contiene l'informazione di 8 pixels) 

dopo aver creato il buffer video si puo' copiarlo sulla vera memoria video per mostrare il risultato

attenzione: nonostante la TI-89 abbia uno schermo di dimensione 160x100 il codice funziona solo con le dimensione di 240x128 ovvero le dimensioni della TI-92 (la sorella maggiore)

#define USE_TI89

#define SAVE_SCREEN // Save/Restore LCD Contents

#include <stdlib.h>

#include <stdio.h>

#include <graph.h>

#include <kbd.h>

#include <string.h>

int _main(void)

{

char virtual[LCD_SIZE];

//PortSet ((void *) 0x4C00, 239, 127);

int i;

for (i=1;i<50;i++)

{

DrawPix(i,i,A_NORMAL);

}

ngetchx();

memcpy (LCD_MEM, virtual, LCD_SIZE);

ngetchx();

PortRestore();

return 0;

}

TI-89 Mandelbrot

 Ho scoperto per puro caso che le calcolatrici Texas Instruments TI-89 (e parenti) hanno al proprio interno un processore della classe 68000 e che possono essere programmate, oltre che in TI-Basic, anche in C...proviamo un po'

Il compilatore C che ho usato si trova a questo link https://github.com/debrouxl/gcc4ti

esistono versioni meno aggiornate ma non sono cosi' complete

Per compilare si va in /trunk/tigcc-linux/scripts e si lancia ./Install

si impostano poi le variabili di ambiente

export TIGCC=/usr/local/share/gcc4ti/

export PATH=$PATH:$TIGCC/bin

il codice di questo post e' ripreso dal precedente post 

le differenze sono :

1) la funzione main in TIGCC si chiama _main (underscore main)

2) sono necessari gli include di stdio e kbd anche se di fatto non sono richiamati dal codice

#define USE_TI89 // produce all types of files

//#define USE_TI92PLUS

//#define USE_V200

#include <stdio.h> // standard ANSI C input/output support

#include <kbd.h>

#include <tigcclib.h>

#define FIXEDPT_WBITS 4

#define WIDTH 160

#define HEIGHT 100

#include "fixedptc.h"

void _main(void) {

ClrScr();

int j,k,i;

float test;

fixedpt Re,Im,DRe,DIm;

fixedpt X,Y,DUE;

fixedpt XN,YN,YNN;

fixedpt A,B;

Re = fixedpt_rconst(-2.00390625); //finestra reale tra -2 e +0.5

Im = fixedpt_rconst(-1.205); //finestra immaginaria tra -1.2 e 1.2

DRe = fixedpt_rconst(0.015625); //2.5/160

DIm = fixedpt_rconst(0.024); // 2.4/100

DUE = fixedpt_rconst(2.0);

A = Re;

for (j=0;j<WIDTH;j++)

{

A = fixedpt_add(A,DRe);

B = Im;

for (k=0;k<HEIGHT;k++)

{

B = fixedpt_add(B,DIm);

X = fixedpt_rconst(0.0);

Y = fixedpt_rconst(0.0);

for (i=0;i<=127;i++)

{

XN=fixedpt_sub(fixedpt_mul(X,X),fixedpt_mul(Y,Y))+A; // (x*x) - (y*y) + A

YN=fixedpt_mul(X,Y); // x*y

YNN=fixedpt_mul(DUE,YN); // 2*x*y

YN=YNN + B; // 2*x*y*+B

test = fixedpt_tofloat(fixedpt_mul(XN,XN) + fixedpt_mul(YN,YN)); //(XN*XN)+(YN*YN)

if (test > 4.0)

{

//png.plot(j,k,1.0,1.0,1.0);

if (i%2) DrawPix(j,k,A_NORMAL);

break;

}

X = XN;

Y = YN;

}

}

}

}

tigcc -O2 -o timand timand.c 

il file binario avra' una estensione .89z (nel caso si compile di per TI-92 sara' .92z)

Per il trasferimento dell'eseguibile tramite cavo USB ho usato il programma TILP funzionante su Linux impostando Direct Link

Una volta trasferito il codice sul dispositivo si puo' eseguire digitando il nome del fie per esempio se il nome del file e' timand come se fosse una funzione ...per esempio timand()

In alcuni casi la calcolatrice puo' non mostrare la linea di comando ma le icone..in questo caso si preme il tasto MODE si scrolla in basso fino all'opzione APP Desktop e se seleziona OFF

Se non si vuole usare un dispositivo fisico si puo' usare l'emulatore TIEmu. In questo caso per caricare l'eseguibile e' sufficiente premere il tasto F10 e selezionare il flie .89z

Stringhe in C

Mi sono rimesso a studiare un po' di C

--------------------------------------------
#include <stdio.h>
#include <stdlib.h>

#include <string.h>


//calcola la lunghezza di una stringa 
// con un ciclo for ed i puntatori
int strlen_for(char *s)
{
    int n;
    for(n=0; *s!='\0'; s++)
        n++;
    return n+1;
}

//calcola la lunghezza di una stringa 
// con un ciclo while ed i puntatori
//il trucco di fine ciclo e' che 
// il terminatore di una stringa in C 
// e' 0 che corrisponde anche alla condizione
// False 

void print_for(char *s)
{
    for (; *s; s++)
        printf("%c",*s);

    printf("\n");
}

// stampa una stringa
void print_while(char *s)
{
    while(*s){
        printf("%c",*s);
        s++;
        }
    printf("\n");
}

//crea una nuova stringa di una lunghezza non predefinita
char *new_string(int lunghezza)
{
    char *transi = malloc(lunghezza + 1);
    memset(transi, 'a', lunghezza);
    transi[lunghezza] = 0;
    return transi;
}

// concatena due stringhe
char *concatena(char *uno, char*due)
{
    //printf("%i\n",sizeof(uno));


    char *transi = malloc(sizeof(uno)+sizeof(due) + 1);
    int contatore = 0;
     for (; *uno; uno++)
     {
        transi[contatore] = *uno;
        contatore++;
     }
     for (; *due; due++)
     {
        transi[contatore] = *due;
        contatore++;
     }
    transi[contatore] = 0;

    return transi;
}


// taglia una stringa
char *taglia(char *stringa,int caratteri)
{
    stringa[caratteri] = 0;
    return stringa;

}

int main()
{
    char *a = "chiara";
    char b[5] = "luca";
    print_for(a);
    print_while(a);
    int lung = strlen_for(b);
    printf("%i\n",lung);

    char *nuova_stringa = new_string(10);
    print_for(nuova_stringa);

    char *nome = "Luca";
    char *cognome = "Innocenti";
    char *unione = concatena(nome,cognome);
    print_for(unione);

    char *tagliato = taglia(unione,5);
    print_for(tagliato);
    printf("%i\n",sizeof(tagliato)+1);

    //array di puntatori
    char *elementi[] = {"Luca", "Innocenti", "Firenze"};

    print_for(elementi[0]);
    print_for(elementi[2]);



    return 0;
}

Arduino Uno blink con Atmel Studio 7

Nota
Nonostante l'uso di Atmel Studio non e' possibile effettuare il debug step by step del programma a meno che di non usare un debugger esterno (come Atmel ICE) del costo di circa 100 euro (esistono in vendita dei dispositivi tipo AVRISP Mkii che pero' risultano essere solo dei programmatori e non dei debuggers)

Negli STM32 con STLink invece si ha gia' a disposizione un  programmatore debugger a basso costo (pochi euro)
----------------------------------------------------------

Atmel Studio 7 si puo' scaricare dal seguente link

Si crea un progetto GCC C Executable

e si seleziona ATMega 328p

si  va al menu Tools/External tools

Si aggiunge un nuovo tool editando Command ed argomenti con (si deve avere gia' installato Arduino IDE e si fa puntare alle directory)

C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude 

-C"C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf" -v -patmega328p -carduino -PCOM11 -b115200 -D -Uflash:w:"$(ProjectDir)Debug\$(TargetName).hex":i 

a questo punto si puo' editare main.c con il seguente codice (la programmazione avviene in C)

--------------------------------------
#define F_CPU 16000000UL  //frequenza del processore

#include <avr/io.h>
#include <util/delay.h>


int main(void)
{
DDRB |= 0B00100000;
    while (1) 
    {
PORTB |= 0B00100000;
_delay_ms(1000);
PORTB &= 0B11011111;
_delay_ms(500);
    }
}

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

si compila con Build Solution (tasto F7) e si fa l'upload  su Arduino Uno  con Tools/Arduino Uno Bootloader

Ma cosa vuol dire il codice sopra riportato. Si fa riferimento al Data Sheet di AVR Mega328p

DDRB (Data Direction Register= indica come settare le porte digitali (la sigla B indica le porte digitali da 8 a 13, C indica i pin analogici e D indica le porte digitali da 0 a 7) se in lettura od in scrittura

PORTB  invece come settare o leggere la porta

DDRB |= 0B00100000; imposta la porta DDB5 come output (fa un OR sul valore della porta stessa con una maschera)

ma come mai proprio la porta DDB5....perche' nella Arduino Uno e' collegata al Pin D13 a cui e' collegato il led 

dopo di cio' con PORTB (ed una serie di AND ed OR con una maschera binaria) viene settato il valore di DDB5 (e quindi del pin D13) a 0 ed 1

il corrispondente sketch Arduino e' ovviamente

--------------------------------------
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  
  delay(1000);                     
  digitalWrite(LED_BUILTIN, LOW);    
  delay(500);                      
}
--------------------------------------

una differenza evidente e' che il codice compilato Arduino IDE e' di 930 bytes mentre il codice C con Atmel Studio e' di soli 176 bytes

Mandelbrot su Pebble

Visto che sono riuscito ad installare SDK Pebble perche' non provarlo con un classico??

Per il codice mi sono basato su altro esempio di Mandelbrot su Pebble presente su GitHub (peraltro fatto molto meglio del mio)

La gestione dello schermo non e' banalissima perche' e' presente una gerarchia di livelli sovrapposti.

Una cosa significativa: non e' possibile avere dati di debug in formato float (non ne capisco il motivo ma e' cosi')

---------------------------------------------
#include <pebble.h>

static Window *schermo;
static Layer *render_layer;

static void disegna(Layer *layer, GContext *ctx)
{
float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int r = 0;

int itera = 40;
int xres=0;
int yres=0;

float a,b,x,y,x_new,y_new;
int i,j,k;

GRect layer_bounds = layer_get_bounds(layer);

xres=layer_bounds.size.w;
yres=layer_bounds.size.h;

a = 0.0;
b = 0.0;
x_new = 0.0;
y_new = 0.0;

float re_factor = (re_max-re_min);
float im_factor = (im_max-im_min);

// scrive messaggi di debug che possono essere letti in shell con il comando
// pebble logs
APP_LOG(APP_LOG_LEVEL_DEBUG,"WIDTH=%d HEIGHT=%d",xres,yres);

for (i=0;i<yres;i++)
    {
    a = re_min+(i*re_factor/yres);
    for (j=0;j<xres;j++)
{

b = im_min+(j*im_factor/xres);
x = 0.0;
y = 0.0;
//APP_LOG(APP_LOG_LEVEL_DEBUG,"X=%d Y=%d",j,i);
for (k=1;k<itera;k++)
{
x_new = (x*x)-(y*y)+a;
y_new = (2*x*y)+b;
if (((x_new*x_new)+(y_new*y_new))>4)
   {
   r = k%2;
   //APP_LOG(APP_LOG_LEVEL_DEBUG,"K=%d R=%d",k,r);
   if (r == 1)
{
GPoint punto = GPoint(j,i);
//window_set_backgroung_color(&windows,GColorBlack);
graphics_draw_circle(ctx,punto,1);
}
   break;
   }
x = x_new;
y = y_new;
}
}
    }

}

static void carica_schermo(Window *window)
{
APP_LOG(APP_LOG_LEVEL_DEBUG,"CARICA SCHERMO");
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_bounds(window_layer);
render_layer = layer_create(bounds);
layer_set_update_proc(render_layer,disegna);
layer_add_child(window_layer, render_layer);
}

static void scarica_schermo(Window *window){
}

static void init(void){
APP_LOG(APP_LOG_LEVEL_DEBUG,"INIT");
schermo = window_create();
#ifdef PBL_SDK_2
window_set_fullscreen(schermo,true);
window_set_backgroung_color(schermo,GColorWhite);
#endif

window_set_window_handlers(schermo,(WindowHandlers){
   .load = carica_schermo,
   .unload = scarica_schermo,
   });
const bool animated=true;
window_stack_push(schermo,animated);
}

static void deinit(void)
{
window_destroy(schermo);
}

int main(void) {
  APP_LOG(APP_LOG_LEVEL_DEBUG,"MAIN");
  init();
  APP_LOG(APP_LOG_LEVEL_DEBUG,"%p",schermo);
  app_event_loop();
  deinit();
}
---------------------------------------------

e visto che ci siamo perche' non provare a pubblicarla sullo store di Pebble (non e' necessario un pagamento)

ed infine la prova reale (tempo di calcolo circa 6 secondi)

Fixed point math e Mandelbrot

Un esempio di utilizzo della matematica a virgola fissa, un metodo di rappresentazione dei numeri reali con un numero prefissato di cifre decimali utilizzato in particolar modo per calcolatori privi di coprocessore matematico (per esempio il software Fractint usava questo tipo di approccio per il calcolo di frattali su processori 386 e 486 all'inizio degli anni 90)

Per effettuare un calcolo dell'insieme di Mandelbrot si puo' usare attualmente la libreria FIXEDPTC (Fixed Point Math Library for C)  (rispetto ad altre librerie, come FPMLib o LibFoixMath , e' possibile settare il proprio formato dati secondo le proprie necessita')

Visto che il calcolo e' tutto compreso per valori inferiori a 8 puo' essere utile, per massimizzare la precisione, usare una rappresentazione 4.28 (4 digit per la parte intera e 28 per la parte frazionaria) su un calcolatore a 32 bit. In questo modo il piu' piccolo numero calcolabile e' 0.00000000372529. Per la rappresentazione grafica e' stata usata la libreria PngWriter gia' usata qui
L'uso della libreria e' abbastanza autoesplicativo...l'unico aspetto un po' confuso e' che per effettuare dei confronti in un ciclo if...then si deve convertire il dato da formato a virgola fissa in float.

mand.c
------------------------------------------------------
#include <pngwriter.h>

#define FIXEDPT_WBITS 4
#define WIDTH 640
#define    HEIGHT 480

#include "fixedptc.h"

int main() {
int     j,k,i;
float    test;
fixedpt Re,Im,DRe,DIm;
fixedpt X,Y,DUE;
fixedpt XN,YN,YNN;
fixedpt    A,B;

pngwriter png(WIDTH,HEIGHT,0,"mandelbrot.png");

Re = fixedpt_rconst(-2.00390625); //finestra reale tra -2 e +0.5
Im = fixedpt_rconst(-1.205); //finestra immaginaria tra -1.2 e 1.2
DRe = fixedpt_rconst(0.00390625); //2.5/640
DIm = fixedpt_rconst(0.005); // 2.4/480
DUE = fixedpt_rconst(2.0);

A = Re;

for (j=0;j<WIDTH;j++)
    {
    A = fixedpt_add(A,DRe);
    B = Im;
    for (k=0;k<HEIGHT;k++)
    {
    B = fixedpt_add(B,DIm);

    X = fixedpt_rconst(0.0);
    Y = fixedpt_rconst(0.0);

    for (i=0;i<=255;i++)
        {
        XN=fixedpt_sub(fixedpt_mul(X,X),fixedpt_mul(Y,Y))+A; // (x*x) - (y*y) + A
        YN=fixedpt_mul(X,Y); // x*y
        YNN=fixedpt_mul(DUE,YN); // 2*x*y
        YN=YNN + B; // 2*x*y*+B
        test = fixedpt_tofloat(fixedpt_mul(XN,XN) + fixedpt_mul(YN,YN)); //(XN*XN)+(YN*YN)
        if (test > 4.0)
            {
            png.plot(j,k,1.0,1.0,1.0);
            break;
            }
        X = XN;
        Y = YN;
        }
    }
    }
png.close();

}
------------------------------------------------------

Per compilare il sorgente si puo' usare i seguenti comandi
------------------------------------------------------
rm mandelbrot.png
g++ mand.c -o mand  -I/usr/local/include  -L/usr/local/lib -lpng -lpngwriter
./mand
display mandelbrot.png
------------------------------------------------------

Utilizzo SQLite con C

Per terminare la carrellata dell'utilizzo di SQLite (gia' visto qui e qui) si vede l'utilizzo con C sia su Linux che su Windows (mediante Dev-C++ con il DevPack SQLite). Verrano ripetute le operazioni (piu' o meno) gia' eseguite con gli altri linguaggi

Nel progetto Dev-C++ si devono impostare l'utlizzo della libreria SQLite come indicato nella figura sottostante

per utilizzare il programma mediante Dev-C++ e' necessario che la libreria libsqlite3-0.dll sia accessibile (nella stessa directory dove viene ubicato l'eseguibile oppure in una directory di sistema di Windows...attenzione che dal sito di SQLite si scarica una dll nominata sqlite3.dll che non funziona all'interno di Dev-C++..si deve impiegare quella inserita nel DevPack)

Altrimenti dentro Linux il file puo' essere compilato con la seguente riga di comando
gcc -o sqlite_test sqlite_test.c  -Wall -O3 -lsqlite3

di seguito viene riportato il codice sorgente che e' sostanzialmente autoesplicativo in quanto effettua delle exec di comandi SQL
------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>


int main(int argc, char **argv){
sqlite3 *db;
char *zErrMsg = 0;
int rc;

rc = sqlite3_open("utenti.db", &db);
if (rc == SQLITE_OK)
{
rc = sqlite3_exec(db, "CREATE TABLE IF NOT EXISTS users  (Id INTEGER PRIMARY KEY,username TEXT, password TEXT, email TEXT)", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);

rc = sqlite3_exec(db, "INSERT INTO users VALUES (NULL,\"luca\",\"password\",\"lucainnoc@gmail.com\")", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);
rc = sqlite3_exec(db, "INSERT INTO users VALUES (NULL,\"chiara\",\"password\",\"chiara@gmail.com\")", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);

sqlite3_stmt *stmt;
rc = sqlite3_prepare_v2(db, "SELECT * FROM users", -1, &stmt, 0);
if (rc == SQLITE_OK) {
int nCols = sqlite3_column_count(stmt);
if (nCols)
{
for (int nCol = 0; nCol < nCols; nCol++)
printf("%s\t", sqlite3_column_name(stmt, nCol));
printf("\n");
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW)
for (int nCol = 0; nCol < nCols; nCol++)
printf("%s\t", sqlite3_column_text(stmt, nCol));
printf("\n");
}
sqlite3_finalize(stmt);
}

rc = sqlite3_exec(db, "DELETE FROM users", NULL, 0, &zErrMsg);
if (rc != SQLITE_OK) fprintf(stderr, "SQL error: %s\n", zErrMsg);

sqlite3_close(db);
} else {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return 1;
}
return 0;

}

Zlib

La libreria Zlib permette la compressione con un metodo simile (ma non uguale all'algoritmo LZW) a quello dei file Zip

per la compilazione si deve utilizzare la stringa sottostante
gcc -Wall -O3 -lz zlib_test.c -o zlib_test

per comprimere i file si utilizza il seguente codice
-----------------------------------------------------
 FILE *infile = fopen(infilename, "rb");
gzFile outfile = gzopen(outfilename, "wb");

char inbuffer[128];
while ((num_read = fread(inbuffer, 1, sizeof(inbuffer), infile)) > 0) {
      gzwrite(outfile, inbuffer, num_read);
}
fclose(infile);
gzclose(outfile);
-----------------------------------------------------

 mentre questo e' per decomprimere un file
-----------------------------------------------------
 gzFile infile = gzopen(infilename, "rb");
FILE *outfile = fopen(outfilename, "wb");

char buffer[128];
while ((num_read = gzread(infile, buffer, sizeof(buffer))) > 0) {
fwrite(buffer, 1, num_read, outfile);
}

gzclose(infile);
fclose(outfile);
-----------------------------------------------------

Esempio Mandelbrot con GD/C e palette personalizzata

In questo esempio viene creato l'insieme di Mandelbrot utilizzando la libreria GD che si puo' installare in Debian mediante

apt-get install libgd2-noxpm-dev
(esiste una versione che include anche il formato xpm ma nel caso non interessa)

Vengono inoltre presentati due metodi per creare delle palette per la gestione dei colori (entrambe a 256 colori)

Palette 1

Palette 2

Link al progetto

Da compilare con clang -Wall -O3 mand_gd.c -o mand_gd -lgd
-------------------------------------------------------

#include <gd.h>
#include <stdio.h>
#include <math.h>
#include <error.h>

#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define RGB2INT(r,g,b)  (b + 256 * g + 256 * 256 * r)

float re_min = -2.0;
float im_min = -1.2;
float re_max = 1.0;
float im_max = 1.2;
int iterazioni = 255;

float a,b;
float x,y,x_new,y_new;
int k,j,i;

FILE *fp = {0};
gdImagePtr img = {0};
char *fname = "./mand_gd.png";
int s, color;
int red, green, blue;
int palette[256] = {0};

int main() {

float re_factor = (re_max-re_min);
float im_factor = (im_max-im_min);

//Inizializza lo schermo
img = gdImageCreateTrueColor(SCREEN_WIDTH, SCREEN_HEIGHT);

// crea la palette
for(s = 0; s < 256; s++) {
red   = (int)(128.0 + 128 * sin(3.1415 * s / 16.0));
green = (int)(128.0 + 128 * sin(3.1415 * s / 32.0));
blue  = (int)(128.0 + 128 * sin(3.1415 * s / 64.0));
palette[s] = RGB2INT(red, green, blue);
}

// crea una seconda palette
s = 0;
for(int ared=0;ared<=255;ared+=51)
{
for(int agreen=0;agreen<=255;agreen+=51)
{
for(int ablue=0;ablue<=255;ablue+=51)
{
palette[s]=RGB2INT(ared,agreen,ablue);
++s;
}
}
}

for (i=0;i<SCREEN_HEIGHT;i++)
{
for (j=0;j<SCREEN_WIDTH;j++)
{
a = re_min+(j*re_factor/SCREEN_WIDTH);
b = im_min+(i*im_factor/SCREEN_HEIGHT);

x = 0;
y = 0;
for (k=0;k<iterazioni;k++)
{
x_new = (x*x)-(y*y)+a;
y_new = (2*x*y)+b;
if (((x_new*x_new)+(y_new*y_new))>4)
{
red   = gdImageRed(img, palette[k]);
green = gdImageGreen(img, palette[k]);
blue  = gdImageBlue(img, palette[k]);
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img,j, i, color);
break;
}
x = x_new;
y = y_new;
}
}
}
if((fp = fopen(fname, "w")) == NULL)
  error(1, 0, "Error - fopen(): %s", fname);
 else {
  gdImagePng(img, fp);
  fclose(fp);
 }
gdImageDestroy(img);
return(0);
}