Копирование 16-битного изображения в gratale на 48-битное изображение rgb

Question

У меня есть необработанные данные из 16-битного изображения в оттенках серого. Я хотел сделать 48-битное изображение RGB, скопировав одно значение во все 3 канала. В настоящее время я делаю:

BYTE *bit=new BYTE[512*512*6]; 
int j=-1; 
int i=0; 
for(int k=0;k<512*512;k++) 
{ 
    bit[i]=ptr[++j]; 
    bit[++i]=ptr[j]; 
    bit[++i]=ptr[j]; 
    bit[++i]=ptr[++j]; 
    bit[++i]=ptr[j]; 
    bit[++i]=ptr[j]; 
    i++; 
} 

Этот код приводит к желтоватым оттенком. Требуется ли что-то вроде сдвигающих бит?

Answer 1

Попробуйте это:

BYTE *bit=new BYTE[512*512*6]; 
int j=-2; 
int i=-1; 
for(int k=0;k<512*512;k++) 
{ 
    bit[++i]=ptr[++++j]; 
    bit[++i]=ptr[j+1]; 
    bit[++i]=ptr[j]; 
    bit[++i]=ptr[j+1]; 
    bit[++i]=ptr[j]; 
    bit[++i]=ptr[j+1]; 
} 

Это будет делать следующее.

первый раунд:

bit[0]=ptr[0]; 
    bit[1]=ptr[1]; 
    bit[2]=ptr[0]; 
    bit[3]=ptr[1]; 
    bit[4]=ptr[0]; 
    bit[5]=ptr[1]; 

второй раунд:

bit[6]=ptr[2]; 
    bit[7]=ptr[3]; 
    bit[8]=ptr[2]; 
    bit[9]=ptr[3]; 
    bit[10]=ptr[2]; 
    bit[11]=ptr[3]; 

... и т.д..

На самом деле вам не нужно i и j:

BYTE *bit=new BYTE[512*512*6]; 
for(int k=0;k<512*512;k++) 
{ 
    bit[6*k]=ptr[2*k]; 
    bit[6*k+1]=ptr[2*k+1]; 
    bit[6*k+2]=ptr[2*k]; 
    bit[6*k+3]=ptr[2*k+1]; 
    bit[6*k+4]=ptr[2*k]; 
    bit[6*k+5]=ptr[2*k+1]; 
} 

---

обратная операция (48-бит 16-бит):

BYTE *bit=new BYTE[512*512*6]; 
for(int k=0;k<512*512;k++) 
{ 
    ptr[2*k]=bit[6*k]; 
    ptr[2*k+1]=bit[6*k+1]; 
} 

Если RGB изображение а не оттенки серого, то вы должны calculate the luminance каждого пикселя и скопировать яркость в 16-битное изображение в оттенках серого:

BYTE *bit=new BYTE[512*512*6]; 
for(int k=0;k<512*512;k++) 
{ 
    unsigned int R=(bit[6*k]<<8)+bit[6*k+1]; 
    unsigned int G=(bit[6*k+2]<<8)+bit[6*k+3]; 
    unsigned int B=(bit[6*k+4]<<8)+bit[6*k+5]; 
    unsigned int Y=(unsigned int)round(0.2126*R+0.7152*G+0.0722*B); 
    ptr[2*k]=Y>>8; 
    ptr[2*k+1]=Y&0xFF; 
} 

Этот код предполагает, что самый старший байт хранится первым (big-endian). Если вы используете мало-Endian хранения:

BYTE *bit=new BYTE[512*512*6]; 
for(int k=0;k<512*512;k++) 
{ 
    unsigned int R=(bit[6*k+1]<<8)+bit[6*k]; 
    unsigned int G=(bit[6*k+3]<<8)+bit[6*k+2]; 
    unsigned int B=(bit[6*k+5]<<8)+bit[6*k+4]; 
    unsigned int Y=(unsigned int)round(0.2126*R+0.7152*G+0.0722*B); 
    ptr[2*k+1]=Y>>8; 
    ptr[2*k]=Y&0xFF; 
}