Newsgroup: it.comp.lang.c++
Titolo: problema con conversione tra tipi di dati (penso)

sto scrivendo un programma in c++ che esegue alcuni calcoli su una bitmap
caricata in memoria. questi calcoli portano i valori dei componenti dei
singoli pixel a sforare 255 e a me serve invece che essi vengano riportati
proporzionalmente a 255 (ovvero che siano normalizzati a 255). ora io trovo
il valore massimo ed il valore minimo cosě (tenete presente che max, min,
bmp[], ptr sono ulong e w, h sono uint):
// FIND HIGHEST/LOWEST VALUES TO BE USED IN 0-255 NORMALIZATION
max = 0; min = 0-1;
for (int ptr=0; ptr<w*h*3; ptr++) {
if (max < bmp[ptr]) {
max = bmp[ptr];
} else if (min > bmp[ptr]) {
min = bmp[ptr];
}
}
quindi normalizzo il tutto a 255:
// NORMALIZE VALUES
for (int ptr=0; ptr<w*h*3; ptr++) {
bmp[ptr] = (unsigned long)((float)(bmp[ptr] - min) / (float)max *
(float)255);
}
e fin qui pare tutto bene, ma quando poi faccio il processo inverso, e dopo
aver denormalizzato:
//DENORMALIZE VALUES
for (int ptr=0; ptr<w*h*3; ptr++) {
bmp[ptr] = (unsigned long)((float)bmp[ptr] / (float)255 * (float)max) + min;
}
applico i calcoli inversi a quelli inziali (che ho testato separatamente e
funzionano), scrivo la bitmap (BMP) con
// OUTPUTTING LOOPs
// COPY SOURCE IMAGE BMP HEADER - WORKING
fseek(fp1, 0, SEEK_SET);
for (int i=0; i<54; i++) {
fputc(fgetc(fp1),fp2);
}
// WRITE DATA CONTAINED IN THE BMP ARRAY IN THE SAME ORDER THEY WERE READ -
WORKING
for (int ptr=0; ptr<w*h*3; ptr++) {
fputc ((unsigned int)bmp[ptr], fp2);
}
ma la bitmap che ottengo č un casino micidiale di puntini "random". Penso di
star facendo qualche casino con le conversioni nei loop di
normalizzazione/denormalizzaione. Qualche idea? Vi ringrazio sin d'ora.
Nota: se desiderate scaricare il codice completo andate su
sourceforge.net/projects/simplify
la funzione che dovete guardare č void test ()

 
forse il problema qui e' in fputc...Cmq dato che hai un bel buffer di 
ulong perche' non scriverlo tutto di botto con fwrite =
fwrite (bmp,w*h*3,sizeof(ulog),fp2);
e il gioco e' fatto
Inoltre sei sicuro che il formato BMP preveda solo un header seguito da 
un elenco di RGB ?
Mi pare di ricordare che BMP sia decisamente piu' complicato di cosi', 
sopratutto perche' prevedere diversi layout a seconda delle 
caratteristiche della BMP

 proporzionalmente a 255 (ovvero che siano normalizzati a 255). 
tempo fa avevo fatto una cosa analoga, piu' in stile c++ avevo scritto
due oggetti funzione, uno per trovare max e min e uno per
normalizzare.
al volo una cosa del tipo:
template<typename T>
class max_min_of : public unary_function<T, void>
{
      T m_min;
      T m_max;
 
      max_min_of() 
              : m_min( /* qui puoi inizializzare ai valori che vuoi,
piu' grande possibile*/),
              m_max(/* qui il piu' piccolo possibile */)
      {
      }  
      void
      operator() (const T& x)
      {
             if.......
                   m_min = ............
      }
      ~max_min_of() 
      {
      }
};
cosi' potevo usare l'algoritmo STL:
max_min_of<int> max_min = for_each(&il_tuo_array[0], &il_tuo_array[0]
+ qualcosa, max_min_of<int>());
alla fine del'algoritmo nella tua istanza hai il valore massimo e
minimo senza troppo codice inutile.
successivamente scrissi un altro oggetto funzione per fare la
normalizzazione vera e propria su tutto l'array
spero ti possa aiutare

 ha scritto nel messaggio
news:Xns94316E3078B2Egi...@213.140.2.16...
