(?)Вывод массива на Контекст Устройства

[samadhi]

Непонимаю, что делаю не так. Есть массив unsigned char*, там находится картинка (монохромная), и нужно вывести её на контекст устройства. Вот код, который пробовал я:

Код:

void CBitmapView::DrawGlyph( 
     int x, int y, int w, int h, // координаты и размеры картинки на экране
     int W, int H, // реальные размеры
     const Byte *bitmap, CDC *pDC // сама картинка и контекст устройства
)
{

	if ( !pDC )
		return;

	CRect rect( x, y, x + w - 1, y + h - 1 );
	
	if ( !pDC->RectVisible( rect ) )
		return;

/*   Способ № 1   */
	UINT nColorsBits = 8;
	UINT nColors = 1 << nColorsBits;

	HPALETTE hPal = CreateGlyphPalette( nColors );

	HPALETTE hOldPal = SelectPalette(pDC->GetSafeHdc(),	hPal, TRUE);
	UINT N = pDC->RealizePalette ();
	
	BITMAPINFO *bm = ( BITMAPINFO * )LocalAlloc( LMEM_FIXED, 
                sizeof(BITMAPINFO) + sizeof(WORD) * nColors );

	bm->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bm->bmiHeader.biPlanes = 1;
	bm->bmiHeader.biBitCount = nColorsBits;
	bm->bmiHeader.biCompression = BI_RGB;
	bm->bmiHeader.biClrUsed = nColors;
	bm->bmiHeader.biClrImportant = 0;

	bm->bmiHeader.biWidth = W;
	bm->bmiHeader.biHeight = -H; // картинка прямостояшая
	bm->bmiHeader.biSizeImage = (DWORD) W * H;
	bm->bmiHeader.biXPelsPerMeter = (300 * 10000) / 254;
	bm->bmiHeader.biYPelsPerMeter = (300 * 10000) / 254;

	
	LPWORD pCol = reinterpret_cast<LPWORD>(bm->bmiColors);
	for (WORD i = 0; i < nColors; i++ )
		pCol[i] = i;
	
	
	int n = StretchDIBits(pDC->GetSafeHdc(),
			    x, y, w, h,
			    0, 0, W, H,
			    (const void*)( bitmap ),
			    bm,
			    DIB_PAL_COLORS,
			    SRCCOPY );

               /*   ...ну или вот так   */

	int n = SetDIBitsToDevice( pDC->GetSafeHdc(), x, y, w, h,
		0, 0, 0, H, (const void*)( bitmap ), 
		bm, DIB_PAL_COLORS );

/*   Способ № 2   */

              HBITMAP m_hBitmap = CreateCompatibleBitmap( pDC->GetSafeHdc(), W, H );
               
	int image_size = W*H;
                ULONG* bitmap_buf = new ULONG [image_size];
  
                for(int i = 0;i<image_size; i++)
                         bitmap_buf[i] = RGB(bitmap[i],bitmap[i],bitmap[i]);
    
	LONG n = SetBitmapBits( m_hBitmap, W*H*sizeof ULONG, 
			(VOID *)bitmap_buf );

	delete bitmap_buf;

                /*   ... ну или вот так   */
                HBITMAP m_hBitmap = CreateBitmap( W, H, 1, nColors, (const void *)bitmap );

	HDC hDCMem = CreateCompatibleDC (pDC->m_hDC);

	HBITMAP hOldBitmap = (HBITMAP)SelectObject (hDCMem, m_hBitmap);

	SetStretchBltMode( pDC->m_hDC, HALFTONE );
	StretchBlt (pDC->m_hDC, x, y, w, h, 
			hDCMem, 0, 0, W, H, 
				  SRCCOPY);

	DeleteObject( (HBITMAP)SelectObject (pDC->m_hDC, hOldBitmap) );

	DeleteDC (hDCMem);

	SelectPalette( pDC->GetSafeHdc(), hOldPal, FALSE );

	DeleteObject( (HPALETTE)hOldPal );
	DeleteObject( (HPALETTE)hPal );

	LocalFree( (HLOCAL) bm );	

}

HPALETTE CBitmapView::CreateGlyphPalette( size_t numcol )
{
	
	COLORREF  backcolor = RGB(255, 255, 255);
	COLORREF forecolor = RGB(0, 0, 0);
	
	size_t palsize = (sizeof(LOGPALETTE) * (numcol) );// - 1) * 
//		sizeof(PALETTEENTRY));
	
	LPLOGPALETTE pLogPal = reinterpret_cast<LPLOGPALETTE>(new BYTE[palsize]);
	
	pLogPal->palVersion = 0x300;
	pLogPal->palNumEntries = static_cast<WORD>(numcol);
	pLogPal->palPalEntry[0].peRed = GetRValue(backcolor);
	pLogPal->palPalEntry[0].peGreen = GetGValue(backcolor);
	pLogPal->palPalEntry[0].peBlue = GetBValue(backcolor);
	pLogPal->palPalEntry[0].peFlags = 0;
	pLogPal->palPalEntry[numcol-1].peRed = GetRValue(forecolor);
	pLogPal->palPalEntry[numcol-1].peGreen = GetGValue(forecolor);
	pLogPal->palPalEntry[numcol-1].peBlue = GetBValue(forecolor);
	pLogPal->palPalEntry[numcol-1].peFlags = 0;
	
	for (size_t i = 1; i < numcol - 1; ++ i)
	{
		double frac = pow(static_cast<double>(i) / (numcol - 1), 1 );
		double r = GetRValue(backcolor);
		r -= frac * (GetRValue(backcolor) - GetRValue(forecolor));
		double g = GetGValue(backcolor);
		g -= frac * (GetGValue(backcolor) - GetGValue(forecolor));
		double b = GetBValue(backcolor);
		b -= frac * (GetBValue(backcolor) - GetBValue(forecolor));

		pLogPal->palPalEntry[i].peRed = static_cast<BYTE>(r + 0.5);
		pLogPal->palPalEntry[i].peGreen = static_cast<BYTE>(g + 0.5);
		pLogPal->palPalEntry[i].peBlue = static_cast<BYTE>(b + 0.5);
		pLogPal->palPalEntry[i].peFlags = 0;
	}

	HPALETTE ret = CreatePalette(pLogPal);
	
	delete pLogPal;

	return ret;

}

А так же использовал IImgCtx, но результат все равно один и тот же - либо чёрная область (W*H), либо мусор какой-то тех же размеров. Картинку я создаю сам, а не считываю из файла

[Джон]

Уй, с первого взгляда не разберёшь. После заполнения ВМР структуры, попробуй сохранить битмап в файл и посмотреть в графическом редакторе. Так можно проверить то, что Гром сказал.

Если картинка нормальная тогда проблемма с выводом.

Вывод можешь проверить так: сделай ВМР ресурс и выведи его по твоему алгоритму.

Ну если совсем ничего, то кричи - поможем

[Джон]

А кстати, под какой системой дело происходит 6.0 или 7.0? MFC+GDI?

[Lex]

Судя по функциям MFC + GDI. Вот весрию MFC определить трудно
Кстати, на первый беглый взгляд вроде все правильно.

[Lex]

Вопрос первый, как картинка записана в массиве?
Побитово или байт на точку?

На сколько я помню, в конце каждой строки в битнапке идут pad байты, для выравнивания строк но границе 4 байт.

[samadhi]

Простите, что забыл упомянуть систему.
Lex прав, это MFC 6.0 + GDI. (Win2k на случай предложения GDI+)

картинка - байт на точку, выглядит где-то так:
00100
01010
10001
11111
10001

если кто не разобрал это буква "А"  

Да, ещё, в файл она сохраняется, и все редакторы её понимают, а вот на экран вывести не могу

[Lex]

samadhi, то, что ты привел, бит на точку. И в этом случае оба твои способа работать не будут.

[samadhi]

Lex, н-н-е совсем, это всё-таки _байт_ на точку, по крайней мере она объявлена как unsigned char... в любом случае сформировать из него понятное Windows'у монохромное изображение, я думаю, возможно.

[Lex]

samadhi, Нет ты в корне не прав, у тебя в картинке идет 1 бит на точку. Если бы был байт на точку, то вот это:
00000100
00001010
00010001
00011111
00010001

не было бы буквой "А", а было бы 8 точек с разными цветами или яркостями.
ТО, что оно у тебя объявлена как unsigned char никоим образом не влияет на количество бит/байт на точку. Ты должен понять, что каждый байт твоей картинки определяет не одну, а 8 точек изображения. Соответствено в первом способе

bm->bmiHeader.biClrUsed = nColors; // где nColors = 2
ну и bm->bmiHeader.biSizeImage = (DWORD) W * H / 8;

во втором способее

Код:

for(int i = 0;i<image_size; i++) 
    bitmap_buf[i] = RGB(bitmap[i],bitmap[i],bitmap[i]); 

должно быть похоже на что-нить такое

Код:

for(int i = 0;i<image_size; i++) 
    bitmap_buf[i] = RGB((bitmap[i / 8] << i%8) & 0x80, 
                                   (bitmap[i / 8] << i%8) & 0x80,
                                    (bitmap[i / 8] << i%8) & 0x80); 

[samadhi]

Lex, скорее всего я что-то не понимаю, всё-таки младенец ещё  .
Объявление массива происходит так:

Код:

typedef unsigned char Byte

Byte *bitmap = new Byte[w*h]; // w, h - рамеры будущей картинки

т.е. как я понимаю на каждый пиксел выделяется 1 байт (256 состояний), сохранить в файл мне удается как 256-цветную картинку. Я может не удачный пример привел, прошу пардона.

Я всё равно попробовал твой код - выстраивает в вертикальную цепочку картинку.

[Lex]

Объявлять картинку можешь как хочешь, лишь бы памяти хватило

Сколько у нее бит на пиксел приходиться 1 или 8 зависит от того, как ты ее формируешь.

Чтобы окончательно разобраться приведи код, который генерит картинку

[samadhi]

Если поможет... там довольно сложно... читаю из файла, а далее:

Код:

void PkRasterdata::construct_bitmap()
{
	bitmap_ = new Byte[w_ * h_];

	// rasterinfo is a pure bitmap - no decoding necessary
	unsigned int nbits_req = w_*h_;

	Byte *p = bitmap_;		

	const Byte *r = rasterdata_;	// rasterdata_ - прочтённое из файлика

	Byte b;

	while (nbits_req >= 8)
	{
		for (int i=7, bb=*r; i>=0; i--, bb>>=1)
			p[i] = static_cast<Byte>(bb&1);

		p += 8;

		r++;

		nbits_req -= 8;
	}
		
	if (nbits_req > 0)
	{
		// get the last few bits
		b = static_cast<Byte>(*r >> (8-nbits_req));

		for (int i=nbits_req-1; i>=0; i--, b>>=1)
			p[i] = static_cast<Byte>(b&1);
	}
}

Я еще пробовал выводить в текстовый файл, когда не умел писать bmp:

Код:

void CTxtBitmap::Write( CString filename, int nWidth, int nHeight, const Byte *bitmap)
{
	CStdioFile file;
	
	try
	{
		if (!file.Open( filename, CFile::modeCreate
				| CFile::modeWrite | CFile::typeText  ))
			return;
	}
	catch(CException * pE)
	{
		pE->Delete();
		return;
	}
	
	
	for ( int i = 0; i < nHeight; i++ )
	{
		CString str;
		
		const Byte *p = &bitmap[ i * nWidth ];
	
		for ( int j = 0; j < nWidth; j++ )
		{		

			if ( *(p + j) )
				str += "0";
			else
				str += "1";

		}

		str += "\n";
		
		try
		{
			file.WriteString( str );
		}
		catch(CException * pE)
		{
			//file.Close();
			pE->Delete();
			return;
		}

	}
		
	file.Close();
}

Э-э-х, трудна и неказиста жизнь простого программиста

[Lex]

А файл какой читаешь?
Как там данные распологаются? Проблема может быть в том, что ширина твоей картинки не кратна 8 и тогда вполе нвероятно, что присутствуют несколько лишних  бит в конце каждой строки, дабы строки были выровнены по границе байта.

[samadhi]

это PK-файл - шрифт для TeX/LaTeX.
Я могу привести код сохранения в файл. Он выдаёт нужный результат.

Код:

Bitmap::Bitmap(int nWidth, int nHeight)
	: m_nWidth(nWidth), m_nHeight(nHeight)
{

	WORD cClrBits = (WORD)8;
	
	max_colour_ = static_cast<BYTE>((1<<cClrBits) - 1);
	
	m_lpDIB = (Byte *) GlobalAlloc(GMEM_FIXED, m_nWidth * m_nHeight );
	
	memset(m_lpDIB, max_colour_, m_nWidth * m_nHeight );

	m_lpBmpInfoHdr = (LPBITMAPINFOHEADER) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER) );

	memset (m_lpBmpInfoHdr, 0, sizeof(BITMAPINFOHEADER));
	
	m_lpBmpInfoHdr->biSize = sizeof(BITMAPINFOHEADER); 
    m_lpBmpInfoHdr->biWidth = m_nWidth; 
    m_lpBmpInfoHdr->biHeight = m_nHeight; 
    m_lpBmpInfoHdr->biPlanes = (DWORD)1;
	m_lpBmpInfoHdr->biBitCount = cClrBits;
	m_lpBmpInfoHdr->biCompression = BI_RGB;
	m_lpBmpInfoHdr->biSizeImage = m_nWidth * m_nHeight;
    m_lpBmpInfoHdr->biClrUsed = (1 << cClrBits); 

	lpRGB = new RGBQUAD[256];

	for(int j = 0; j < 256; j++)
	{
		lpRGB[j].rgbRed   = j;
		lpRGB[j].rgbGreen = j;
		lpRGB[j].rgbBlue  = j;
		lpRGB[j].rgbReserved = 0; 
	}



}


BOOL Bitmap::write( CString strFileName )
{
	
	HANDLE hf;                 
    
	BITMAPFILEHEADER hdr;      
    DWORD dwTmp; 

    // Create the .BMP file. 
    hf = CreateFile((LPTSTR)(LPCTSTR)(strFileName), GENERIC_WRITE, 
                   (DWORD) 0, NULL, CREATE_ALWAYS, 
                   FILE_ATTRIBUTE_NORMAL, (HANDLE) NULL); 
    
	if (hf == INVALID_HANDLE_VALUE) 
	{
        AfxMessageBox("write - INVALID_HANDLE_VALUE"); 

		return FALSE;
	}

	memset (&hdr, 0, sizeof(hdr));
    
	hdr.bfType = 0x4d42; // 0x42 = "B" 0x4d = "M" 
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
                    sizeof(BITMAPINFOHEADER) + 1024; 
	hdr.bfSize = hdr.bfOffBits + 
		sizeof(BYTE) * m_nWidth * m_nHeight + 
		m_nHeight * ((3*m_nWidth) % 4);

   
	
	// Copy the BITMAPFILEHEADER into the .BMP file. 
    WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL);


    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file. 
    WriteFile(hf, (LPVOID) m_lpBmpInfoHdr, sizeof(BITMAPINFOHEADER), 
                  (LPDWORD) &dwTmp, ( NULL));

	WriteFile( hf, (LPVOID)lpRGB, /*lpBitmapHeader->biClrUsed*/256 * sizeof (RGBQUAD),
		(LPDWORD)&dwTmp, NULL );

	for ( int i = m_nHeight - 1; i >= 0 ; i-- )
	{

		WriteFile( hf, m_lpDIB+(i*m_nWidth), m_nWidth, &dwTmp, NULL );

		WriteFile (hf, lpRGB, (3 * m_nWidth) % 4, &dwTmp, NULL); // забиваем мусором
	
	
	}

    CloseHandle(hf);

	return TRUE;

}

[Lex]

Ничего не понимаю.

Скинь мне свою прогу на lex@hotmail.ru
Где-то у тебя идет путаница с форматами представления твоей картинки

[samadhi]

Lex, это будет тяжеловато сделать, поскольку прога разбитта на библиотечку и саму прогу, кроме того нужно перекачивать шрифты и файлик с dvi - документ. Я попробовал предложенный Джоном вариант, запихнул в ресурс бмп-шку и вывел её - вывод работает, правда, через создание hMemDC (второй способ), что медленнее работает; первый - выдал фантан пикселей . Попытаюсь поиграться с ним.

[samadhi]

Эге-ге-е-й, мужики, уменя ПОЛУЧИЛОСЬ   .Lex, ты АБСОЛЮТНО прав. Я залез в класс, который сохраняет картинку на диск, биты там объявлены как BYTE в MSDN'е читаю : BYTE - An 8-bit integer that is not signed, а я в перерисовке использовал unsigned char.

ПАСИБА!!!

[Lex]

Пажалуйста, обращайся еще

[Джон]

samadhi, рад за тебя, только я теперь нифига не понял - разве BYTE это не то-же самое, что "unsigned char"?

typedef byte BYTE;
typedef unsigned char byte;

[samadhi]

Джон, вообще-то, да char - 8-битный целочисленный тип. У меня, почему-то только так получилось. Н-н-е, понимаю :?.

[Джон]

Вот и я не понял...
"Да есть, друг Горацио, на свете вещи, которые не снились вашим мудрецам"

[Lex]

samadhi, ты скорее всего где о потерял unsigned и использовал просто char, который знаковый.
BYTE в заголовках объявляется как

Код:

typedef unsigned char BYTE

[samadhi]

нет, что вы, Бил Гейтс с вами, как такое можно забыть, тогда у меня бы вся длл-ка материлась.

В том классе, где пользую BYTE, я копирую картинку, где-то так:

Берём каждый unsigned char и
if (*p)
  *P=*p;

и всё

[Lex]

А поподробнее с объявлением преременных. и как у вас вначале это было