Newsgroup: it.comp.lang.c++
Titolo: Come sommare unsigned char...

Il mio problema è questo.
Voglio caricare "n" immagini in memoria e restituire in output un file 
unico che dia le immagini messe in sequenza ovvero un file che contenga 
la sequenza delle immagini caricate una in coda l'altra.
Avevo pensato di creare una lista concatenata di immagini per poi 
prendere di ogni singola immagine l'"unsigned char" dove l'ho scaricata 
  e creare un nuovo unsigned char di dimensione n * (dimensione singolo 
unsighed char) su cui scaricare l'uno dietro l'altro gli unsigned char.
Mi chiedevo se qualcuno poteva darmi una mano su come creare una 
funzione del genere.
Spero di essermi fatto capire ,almeno in parte :-), nonostante 
l'italiano maccheronico.

 funzione del genere.
Uhm... Potresti dettagliare esattamente cosa intendi per "l'unsigned char 
dove l'hai scaricata"?
Hai un esempio di codice da postare?
Ciao!
-- 
---
*************** | Have you ever retired a human by mystake?
*** Azathot *** |
*************** | To contact me, ask me gently. Thanks.

Hai ragione...non sono stato molto chiaro.
Ho una struttura di questo genere
struct image{
	int dimx;
	int dimy;
	int buffersize;
	unsigned char*buffer;
	image]next;
	};
Per leggere il file immagine che mi interessa uso una funzione di questo 
tipo:
int load_file(struct image *im, char*nomefile, int colonne, int righe)
{
	FILE *fin;
	int dx, dy;
	int x, y;
 
	fin = fopen(nomefile,"rb");
	if  (fin==NULL)
	  {
	    fprintf(stderr, "File non trovato !!!");
	    return -1;
	  }
	dx = colonne;
	dy = righe;
	recreate_image(im,dx,dy); //alloco lo spazio per creare un'immagine 
temporanea
 
	for(y=0;y<dy;y++)
	  for(x = 0;x < dx;x++)
              put_GL(im,x,y,getc(fin));
	return 0;
}	
la funzione put_GL č cosě implementata :
in put_GL(struct image*im, int x, int y, unsigned char gl)
{
	if((x >=im->dimx) || (x < 0) || (y >= im->dimy) || (y > 0))
//controlllo che mi serve per altre funzioni
	  {
	         return -1;
	  }
	else
	  {
	     im->buffer[y*im->dimx+x]=gl; //qui inserisco i grey level 
dell'immagine
	     return 0;
	  }
}
Il mio problema era quello di prendere un numero n di immagini e 
inserirle in sequenza d'acquisizione in unico file immagine.
Spero adesso sia piů chiaro.

 Spero adesso sia più chiaro.
Ora un po' di più: prova con questa funzione...
        Image Fusion( const Images& _imgs ) {
                Image dest = CreateImage( _imgs.front().dim_x, _imgs.front().dim_y );
                Images::iterator it;
                for( it = _imgs.begin(); it != _imgs.end(); ++it )
                        for( int y = 0; y < dest.dim_y; ++y )
                                for( int x = 0; x < dest.dim_x; ++x )
                                        (dest.buffer.get())[y*dest.dim_x+x] 
                                                += ((*it).buffer.get())[y*dest.dim_x+x]
                return dest;
        }
Guarda, è stata scritta di getto, quindi potrebbe contenere degli errori... 
cmq, prova a compilarla e poi dimmi...
In ogni caso, Image è suscettibile di classificazione...


Il fatto è che il progetto l'ho scritto tutto in C.
Ci sono cose che hai scritto che non conosco per esempio alcuni usi che 
hai fatto delle STL.
Spero di venirne a capo lo stesso.
Volevo mostrarti questo frammento di codice e dirmi cosa ne pensi e cosa 
cambiare.È fatto solo per tirar su 2 immagini messe in lista concatenata 
ma purtroppo non funziona....in uscita mi dà un immagine unica che non 
centra un granchè con quelle passate in ingresso :-)
struct image* alloca_stack_bsq(struct image* t,int x, int y, int num_bande)
{
   unsigned char buffi[x*y*num_bande];
   int buff, cont, cont2, buffo;
   buff = x*y;
   buffo = x*y*num_bande;
   //cont2 = 0;
   //cont = cont2;
     for(cont = 0; cont < buff; cont++)
       buffi[cont] = t->buffer[cont];
     t->next = t;
       for(cont = buff+1; cont < (buff+buff); cont++)
	  buffi[cont] = t->buffer[cont - buff + 1];//ho usato questo metodo per 
scrivere in coda all'immagine precedente voglio che il buffer in t conti 
da zero fino a fine immagine mentre in buffi voglio che conti dalla fine 
di quello precedente fino a fine buffer
       struct image*temp = new image;
       temp->dimy=-1;
       temp->dimx=-1;
       temp->buffersize=-1;
       temp->buffer=NULL;
       temp->next=NULL;
       temp->dimy=x;
       temp->dimx=y;
       temp->buffersize=x*y*num_bande;
       temp->buffer=new unsigned char[buffo + 1];
       for(int conta = 0; conta < buffo; conta++)
	temp->buffer[conta] = buffi[conta];
       t =temp;
       return temp;
}

 ci pensa l'auto_ptr a rimuoverti l'area allocata.
Attento, ho la sensazione che tu voglia impiegare l'auto_ptr<> come una 
sorta di puntatore "intelligente", che sappia e possa decidere quando č 
sicuro distruggere l'oggetto a cui punta. Se vuoi poter inserire oggetti 
allocati dinamicamente in un container senza occuparti esplicitamente della 
loro distruzione, devi riccorre a meccanismi piů sofisticati dell'auto_ptr; 
per esempio, i cosidetti smart pointer con reference counting (vedi Boost).
Max

 sorta di puntatore "intelligente", 
Cmq, l'uso che ne volevo fare era compatibile con la semplicità degli 
auto_ptr... cmq, non c'è problema: eliminiamoli pure. :)


 Il fatto è che il progetto l'ho scritto tutto in C.
Allora direi che ti conviene passare su "it.comp.lang.c": sicuramente lì 
troverai qualcuno che ti potrà aiutare in maniera più specifica riguardo 
questo linguaggio (che è differente dal C++)! :)


Hai ragione.
Pensavo che chi conosceva il C++ conosceva ancora meglio il C :-)
Cmq adesso ho postato su it.comp.lang.c.
Grazie dell'aiuto .

 elemento di un container standard.
	Ecco, ma questo vale per *tutti* i container, o solo quelli che possono
venire riallocati? Cioe', siamo d'accordo che valga per std::vector, ma vale
anche per std::list?
	Rispondetemi con tatto perche' potrei avere tonnellate di codice da
buttare a mare :)
_dave_

 buttare a mare :)
Se hai container di auto_ptr<> o di struct contenenti auto_ptr<>,
sbarazzatene. Una soluzione rapida potrebbe essere quella di rimpiazzare gli
auto_ptr con degli smart pointer come quelli della libreria di Boost.
Max

 Grazie dell'aiuto .
Ciao.

 requisito.
	Ok, ma perche' un container dovrebbe poter copiare i suoi elementi? Un
vettore che cresce magari deve riallocare della memoria e copiare il suo
contenuto, ma una lista? Una volta allocata della memoria per un suo
elemento, quella rimane... o no?
_dave_

 realizzati con strutture del "C" ! :)))
come mai non usare i traduttori da C++ a C ??? visto che come leggo e come
mi pare di capire ingiro ci sono alcuni compilatori/traduttori che
trasformano un sorgente C++ in un sorgente C (per poi compilarlo con il
compilatore C)
almeno non sprechi piu' mezzora per abbandonare il C++ ed ottieni il
programma C da consegnare :-p
magari poi questo passaggio intermedio apre anche altre strade di
ottimizzazione ?
ciao

 ottimizzazione ?
O di pessimizzazione? :)
Saluti.

 O di pessimizzazione? :)
dai vabbe che il C++ e' un po piu' lento ma non cosi' tanto ...
ciao

 dai vabbe che il C++ e' un po piu' lento ma non cosi' tanto ...
No, io parlavo di lentezze introdotte nel processo di conversione d C++ a C.
Saluti.

 ha scritto nel messaggio
news:bi9p1n$gd$1...@lacerta.tiscalinet.it...

bhe quelle sono minime e delegate al compilatore ... poi bisogna vedere se
stai compilando 300mb di sorgenti o solo 1mb ... che cmq con i makefile ti
risolvi che dopo la prima lunga compilazione le successive ricompili solo i
sorgenti cambiati ...
cmq penso che per uno che si trova da dio con la STL usare la conversione
automatica in C dovrebbe essere una bella cosa per tagliare i tempi che
impiegherebbe a riusare tutte le funzioni C (alcune veramente con nomi
astrusi :-p)
ciao

 elemento, quella rimane... o no?
Gia', ma all'inizio dovra' pure inserirli, no?
Ciao,
Nicola

 Gia', ma all'inizio dovra' pure inserirli, no?
	Hai ragione, sono un pirla. Il problema e': per aggirare questo problema
ho dovuto dichiarare mutable un paio di membri dato di una mia classe che
tiene i reference count. Da uno a dieci quanto fa schifo questa soluzione,
secondo voi?
_dave_