Высота, ширина, цвет точки HBITMAP-а , без модуля Graphics

Если загрузить битмап из файла в переменную типа HBITMAP так:

var
hBmp: HBITMAP;
...
hBmp := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

Как можно узнать его высоту, ширину, и цвет в какой-то определенной точке не прибегая к модую Graphics?

function PictureSize: TSize;
var
  ResHandle: HWND;
  ResData: HWND;
  BMI: PBitmapInfo;
begin
  Result.cx := 0;
  Result.cy := 0;
  ResHandle := FindResource(HInstance,
    MAKEINTRESOURCE(200), RT_BITMAP);
  if ResHandle <> 0 then
  begin
    ResData := LoadResource(HInstance, ResHandle);
    if ResData <> 0 then
    try
      BMI := LockResource(ResData);
      if Assigned(BMI) then
      try
        Result.cx := BMI.bmiHeader.biWidth;
        Result.cy := BMI.bmiHeader.biHeight;
      finally
        UnlockResource(ResData);
      end;
    finally
      FreeResource(ResData);
    end;
  end;
end;

А цвет точки - у структуры PBitmapInfo есть параметр bmiColors, который является массивом структур TRGBQuad в котором и содержиться информация по каждому пикселю.

Добавлено 07.12.06, 11:49
Пардон, у тебя из файла загрузка, тогда через GetDIB получай указатель на PBitmapInfo и по аналогии

Я тут так подумал, может лучше так будет?

размер:

var
  size: tagSIZE;
...
GetBitmapDimensionEx(hBmp, size);

цвет:

color := GetPixel(hBmp, x, y);

Может и лучше, но не факт что быстрее

Цитата Dmitry_177 @ 07.12.06, 14:17

цвет:

color := GetPixel(hBmp, x, y);

Вообще-то GetPixel первым параметром принимает контекст устройства, а не дескриптор bitmap'а.
Можно сделать как-нибудь так

var
 bmp, oldbmp:HBITMAP;
 bmpInf:BITMAP;
 DC,MemDC:HDC;
 bWidth,bHeight:integer;
 color:COLORREF;
begin
 bmp:=LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
 DC:=GetDC(0);
 MemDC:=CreateCompatibleDC(DC);
 oldbmp:=SelectObject(MemDC,bmp);
 GetObject(bmp,sizeof(BITMAP),@bmpInf);
 bWidth:=bmpInf.bmWidth;       // ширина
 bHeight:=bmpInf.bmHeight;     // высота
 color:=GetPixel(MemDC,10,10); // цвет
 SelectObject(MemDC,oldbmp);
 DeleteDC(MemDC);
 ReleaseDC(0,DC);
end;

Вот если делать через GetDIBits, у меня возникло несколько вопросов:

var
  memDC: HDC;
  hBkgnd: HBITMAP;
begin
  hBkgnd := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
 
  memDC := GetDC(0);
  GetDIBits(memDC, hBkgnd, 0, 0, nil, BMI, DIB_RGB_COLORS);
  ReleaseDC(0, memDC);
 
  if (BMI.bmiColors[0].rgbRed = 255) and (BMI.bmiColors[0].rgbGreen = 0) and (BMI.bmiColors[0].rgbBlue = 0) then
    MessageBox(0, '0 - Красный', '', 0);
 
end;

Правильно ли я создаю контекст устройства memDC := GetDC(0);?

Не понятно что это за массив bmiColors, как так идет счет точек что-то я не пойму, там же всего одно число а не два, например x и y... Объясните пожалуйста..

IMHO

memDC := GetDC(0);

это получение контекста рабочего стола

Приветствую всех!
Мой вопрос почти по этой теме.
Дело в том что GetObject воздвращает bmBitsPixel равное текущему BPP десктопа, то есть, например, всегда 32 у меня, так как стоит цвет 32 High Color. Соответсвенно при смене на 16 - даже 24ый битмап опознаётся как 16ый. То есть возвращается то как он конкретно сейчас конкретно на этом Compatible устройстве будет выведен. Но меня это пока не очень интересует.
Как бы мне получить реальный BPP битмапа? То есть то сколько бит на пиксель записано в фаиле?
(HBITMAP загружается - всё нормально, GetDIBits - работает нормально, то есть возвращает 3 * W * H в случае с 24 битным битмапом.)
Неужели надо размер массива полученных точек делить на площадь его?

Цитата Rouse_ @ 07.12.06, 11:48

А цвет точки - у структуры PBitmapInfo есть параметр bmiColors, который является массивом структур TRGBQuad в котором и содержиться информация по каждому пикселю

Разве? Совсем нет. И кстати, для полноцветных битмапов данные в файле могут храниться структурах как RGBQUAD так и в RGBTRIPLE (определяется по BITMAPINFOHEADER.biBitCount).

Цитата Dmitry_177 @ 10.12.06, 16:03

Не понятно что это за массив bmiColors

Массив bmiColors содержится только в неполноцветных файлах, и это не цвета точек, это палитра. Сам массив изображения как правило начинается за массивом bmiColors. Но если рисунок полноцветный, то этот массив в файле отсутствует.
ЗЫ: никогда не вычисляй размер bmiColors через BITMAPINFOHEADER.biBitCount, т.к. если рисунок к примеру 256-ти цветный, то не факт что и записей в палитре будет 256. Как правило меньше.

Добавлено 10.12.06, 20:48

Цитата WDaft @ 10.12.06, 19:40

Как бы мне получить реальный BPP битмапа? То есть то сколько бит на пиксель записано в фаиле?

Очень просто. Считывай заголовок с помощью BlockRead(sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER)). Затем, если BITMAPINFOHEADER.biBitCount равен 16,24 или 32 то файл не содержит палитры, и размер рассчитывается как (W * H * (biBitCount / 8)).
Если biBitCount равен 1,2,4 или 8 то нужно расчитать размер палитры. Ее размер можешь вычислить как (sizeof(RGBQUAD) * biClrUsed). Сразу за ней и начинается изображение.
А теперь тонкости(мягкотелые без них не могут Заголовок файла бывает двух видов:
BITMAPINFOHEADER и BITMAPCOREHEADER. Если попался CORE, то палитра хранится в формате RGBTRIPLE и ее размер расчитывается по bcBitCount. Это во первых. Во вторых старайся использовать как можно меньше полей заголовка, поскольку встречаются отклонения от стандарта, сам вычисляй. В третьих, палитровые рисунки могут быть сжаты по RLE. В четвертых, заголовки можешь определить по bcSize. В пятых - поле bfSize частенько некорректное, а BITMAPINFOHEADER начинается сразу за BITMAPFILEHEADER. Остальное мелочи

AndNot, 10x! =)
Я предвидел ответ в виде этого метода. И всё же - нет ли WinAPIшного метода для определения битности по HBITMAPу?
Или только так?

Вот и фиг то что не припомню А загрузку подобным образом не только я делал, т.ч. может не зря?

Добавлено 10.12.06, 21:19
А разве сложно через заголовок посмотреть BPP?

Не так сложно, но разве Микрософтовцы при загрузке Битмапа ИХНЕЙ же функцией не знают какой там BPP записан? Какого они кроют от нас эту инфу теперь?
И ведь всё равно при GetDIBits получается массив именно столько байт на пиксель, сколько в файле - то есть всё правильно.

Цитата WDaft @ 10.12.06, 22:10

Битмапа ИХНЕЙ же функцией не знают какой там BPP записан?

Зачем им это?

Цитата WDaft @ 10.12.06, 22:10

Какого они кроют от нас эту инфу теперь?

Я переправлю дидюшке биллу

Цитата WDaft @ 10.12.06, 22:10

И ведь всё равно при GetDIBits получается массив именно столько байт на пиксель, сколько в файле - то есть всё правильно.

И это естественно, поэтому и есть функции преобразования к нужному тебе формату, при этом не обязательно знать уже загруженный, вот и получилась такая хрень. Хотя черт ее знает, может и есть какая апи.

Цитата AndNot @ 10.12.06, 20:19

Разве? Совсем нет.

Да? Странно, а вот спецификация данного формата говорит что да:

Цитата

Each bitmap file contains a bitmap-file header, a bitmap-information header,
a color table, and an array of bytes that defines the bitmap bits. The file
has the following form:

BITMAPFILEHEADER bmfh;
BITMAPINFOHEADER bmih;
RGBQUAD aColors[];
BYTE aBitmapBits[];

The bitmap-file header contains information about the type, size, and layout
of a device-independent bitmap file. The header is defined as a
BITMAPFILEHEADER structure.

The bitmap-information header, defined as a BITMAPINFOHEADER structure,
specifies the dimensions, compression type, and color format for the bitmap.

The color table, defined as an array of RGBQUAD structures, contains as many
elements as there are colors in the bitmap. The color table is not present
for bitmaps with 24 color bits because each pixel is represented by 24-bit
red-green-blue (RGB) values in the actual bitmap data area. The colors in the
table should appear in order of importance. This helps a display driver
render a bitmap on a device that cannot display as many colors as there are
in the bitmap. If the DIB is in Windows version 3.0 or later format, the
driver can use the biClrImportant member of the BITMAPINFOHEADER structure to
determine which colors are important.

Цитата Rouse_ @ 11.12.06, 08:27

Странно, а вот спецификация данного формата говорит что да

Ну и где здесь сказано что:

Цитата Rouse_ @ 07.12.06, 11:48

А цвет точки - у структуры PBitmapInfo есть параметр bmiColors, который является массивом структур TRGBQuad в котором и содержиться информация по каждому пикселю

bmiColors это именно массив палитры (в вышеприведенном файле это - RGBQUAD aColors[]), который у полноцветных отсутствует(в таком случае этого поля просто нет). Цвета точек расположены в массиве "BYTE aBitmapBits[]", сразу за палитрой(если есть), о чем я и толковал. И даже в большинстве непалитровых битмапов каждая точка хранится в структуре RGBTRIPLE, т.к. 32-х разрядные появились опосля(также как и 16-ти битные).
Несколько лет назад писал загрузчик бмп,кур и иконок под дос. Посмотри кусочек:

        sub     esp,size BitmapInfoHeader
        mov     edx,esp
        mov     ecx,size BitmapCoreHeader
        mov     esi,edx         ; esi   - входной буффеp
        mov     ah,3Fh
        int     21h             ; считали заголовок
    __core:                     ; пpедполагаем что заголовок BitmapCoreHeader
        movzx   ecx,[esi+BitmapCoreHeader.biBitCount]
        cmp     [esi+BitmapCoreHeader.biSize],size BitmapCoreHeader
        je      __read_palette
    __win:                      ; заголовок BitmapInfoHeader
        mov     ecx,size BitmapInfoHeader - size BitmapCoreHeader
        mov     ah,3Fh
        int     21h             ; считываем остаток заголовка
        movzx   ecx,[esi+BitmapInfoHeader.biBitCount]
 
        ; считываем и конвеpтиpуем палитpу (если нам это надо ;-)
    __read_palette:
        cmp     cl,18h
        je      __select_outpnt ; -> pисунок полноцветный,уходим!
        push    ecx             ; сохpаняем BPP
        ; получаем количество цветов
        mov     ebx,1
        shl     ebx,cl          ; ebx - количество цветов
        ; выделяем память под палитpу
        lea     ecx,[ebx*4]
        call    Alloc PASCAL,ecx
        xchg    edx,eax
        cmp     [esi+BitmapCoreHeader.biSize],size BitmapCoreHeader
        jne     __win_pal       ; -> виндозный pисунок
        sub     ecx,ebx         ; ecx - pазмеp палитpы в байтах
        mov     ah,3Fh
        int     21h             ; считываем палитpу
        ; пpеобpазуем в RGBQuad
        xchg    ecx,ebx         ; ecx - количество цветов
                                ; ebx - pазмеp палитpы в байтах
        push    esi
        lea     edi,[edx+ecx*4-4]
        lea     esi,[edx+ebx-3]
        std
        xor     eax,eax
    __conv_pal:
        movsw
        lodsb
        stosw
        loop    __conv_pal
        cld
        pop     esi
        jmp     short __end_pal
 
    __win_pal:
        cmp     [esi+BitmapInfoHeader.biClrUsed],0
        je      __read_pal
        ; использована не вся палитpа
        mov     ebx,[esi+BitmapInfoHeader.biClrUsed]
    __read_pal:
        shl     ebx,2           ; ebx - pазмеp палитpы в байтах
        xchg    ecx,ebx         ; ecx - pазмеp палитpы
        mov     ah,3Fh
        int     21h             ; считываем палитpу
        xchg    edx,edi
 
        ; палитpа обpаботана
    __end_pal:
        pop     ecx

Если есть желание разбираться, то увидишь, про что я все это время толковал
Код кстати рабочий. Проверен на сотнях бмпшек всех разновидностей.

Цитата AndNot @ 11.12.06, 15:15

Если есть желание разбираться, то увидишь, про что я все это время толковал

Спасибо, не нужно У меня на сайте тоже есть пример работы 32-битные битмапы действительно не содержат палитру, но данные храняться в виде RGBQUAD. Собственно вот пример смешения цветов двух битмапов, где DIBColorSrc указатель на область данных о пикселях загруженного битмапа (надеюсь все в курсе5 что внутри иконки лежат битмапы? ):

procedure MakeAlphaBlend(DIBColorSrc, DIBDest: PRGBQuad;
  const DIBColorSrcSize: Integer); assembler;
asm
 
  // Запоминаем значение регистров в стеке
 
  push eax
  push ebx
  push ecx
  push edx
  push edi
  push esi
 
  mov  esi, DIBColorSrc       // карта цветов иконки
  mov  edi, DIBDest           // карта цветов фона
  //mov  ecx, DIBColorSrcSize   // размер массивов (приходит в ECX сам по себе)
 
  shr  ecx, 2                 // размер элемента массива равен четырем,
                              // поэтому поправим счетчик цикла
 
// -----------------------------------------------------------------------------
 
@loop:
 
  // цвета представленны следующим образом
  // [esi]  = синий
  // [esi + 1]  = зеленый
  // [esi + 2] = красный
  // [esi + 3]  = альфа канал
 
  mov  al, [esi + 3]          // читаем значение альфа канала
  cmp  al, 0                  // есть ли изображение иконки в данном пикселе?
  jne  @paint_full
 
  add  esi, 4                 // если нет - берем следующий элемент
  add  edi, 4
  loop @loop
  jmp  @done
 
// -----------------------------------------------------------------------------
 
@paint_full:
  cmp  al, 255                // Смотрим интенсивность цвета
  jne  @paint_alpha
 
  mov  eax, [esi]             // Данный пиксель полностью заполнен цветом иконки
  mov  [edi], eax             // копируем его целиком
 
  add  esi, 4                 // берем следующий элемент
  add  edi, 4
  loop @loop
  jmp  @done
 
// -----------------------------------------------------------------------------
 
@paint_alpha:
 
  // присутствует альфаканал
  
  xor  ebx, ebx
  call @make_alpha            // микшируем синий цвет
  inc  ebx
  call @make_alpha            // микшируем зеленый цвет
  inc  ebx
  call @make_alpha            // микшируем красный цвет
 
  add  esi, 4                 // берем следующий элемент
  add  edi, 4
  loop @loop
  jmp  @done
 
// -----------------------------------------------------------------------------
 
@make_alpha:
 
  // функция смешивает два цвета в зависимости от значения EBX,
  // которое указывает какой именно брать байт из RGB
 
  xor  eax, eax
  xor  edx, edx
  mov  al, byte [edi + ebx]   // берем цвет приемника
  mov  dl, byte [esi + 3]     // берем значение альфаканала
  not  dl                     // значение альфаканала вычитаем из 255
  mul  dl                     // умножаем на получившееся значение
  or   dl, $FF
  div  dl                     // делим на 255
 
  mov  byte [edi + ebx], al   // запоминаем первый результат
 
  xor  eax, eax
  xor  edx, edx
  mov  al, byte [esi + ebx]   // берем цвет источника
  mov  dl, byte [esi + 3]     // берем значение альфаканала
  mul  dl                     // умножаем на значение альфаканала
  or   dl, $FF
  div  dl                     // делим на 255
 
  xor  edx, edx
  mov  dl, byte [edi + ebx]   // читаем первый результат
  add  ax, dx                 // к нему прибавляем второй результат
  mov  byte [edi + ebx], al   // сумму помещаем обратно
 
  ret
 
// -----------------------------------------------------------------------------  
 
@done:
 
  // Восстановление значений регистров из стека
  
  pop  esi
  pop  edi
  pop  edx
  pop  ecx
  pop  ebx
  pop  eax
end;

А еще мне не понятна область lpvBits если само содержимое битмапа копируется, посмотрел в описании функции:
function GetDIBits(DC: HDC; Bitmap: HBitmap; StartScan, NumScans: UINT; Bits: Pointer; var BitInfo: TBitmapInfo; Usage: UINT): Integer; stdcall;
Я как понял это указатель на буфер цветов, а вот как его объявлять не пойму никак...

И еще, при считывании размеров:

 var
  memDC: HDC;
  hBkgnd: HBITMAP;
  BMI: TBitmapInfo;
begin
  hBkgnd := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
 
  memDC := GetDC(0);
  GetDIBits(memDC, hBkgnd, 0, 0, nil, BMI, DIB_RGB_COLORS);
  ReleaseDC(0, memDC);
end;

BMI.bmiHeader.biWidth и BMI.bmiHeader.biHeight (пускай хоть и отрицательный) не правильно определяются ширина с высотой, т.е. Реальные размеры картинки 283 x 149, если посмотреть в свойствах файла в виндовсе, а у меня определяется как 70 x 5...

Что-то я не пойму никак что не так...

Цитата Rouse_ @ 11.12.06, 16:01

32-битные битмапы действительно не содержат палитру, но данные храняться в виде RGBQUAD

А есть еще 24-х и 16-ти битные. На них твой пример и загнется

Цитата Rouse_ @ 11.12.06, 16:01

надеюсь все в курсе5 что внутри иконки лежат битмапы?

Там еще и маски есть

Цитата Rouse_ @ 11.12.06, 16:01

У меня на сайте тоже есть пример работы

И на основании этого ты и сделал вывод что в bmiColors[] хранится цвет точек? Этот пример совершенно не показывает структуру BMP

Цитата Dmitry_177 @ 11.12.06, 16:49

А еще мне не понятна область lpvBits

Я так понял. Это буфер для образа рисунка, т.е. если нужно преобразовать битмап не в контекст устройства(DC) а в буфер, то в этом параметре передаешь на нее указатель. После чего сможешь легко определить любой пиксель Собственно из-за этого параметра и весь сыр-бор.

Цитата Dmitry_177 @ 11.12.06, 16:49

Я как понял это указатель на буфер цветов, а вот как его объявлять не пойму никак...

GetMem()

Цитата Dmitry_177 @ 11.12.06, 16:49

Реальные размеры картинки 283 x 149, если посмотреть в свойствах файла в виндовсе, а у меня определяется как 70 x 5...

Ты сам должен корректно заполнять этот заголовок, прежде чем скормишь его GetDIBits.
И кстати, вместо GetDC(0) попробуй так:

  memDC := CreateCompatibleDC(0);
  GetDIBits(memDC, hBkgnd, 0, 0, nil, BMI, DIB_RGB_COLORS);
  DeleteDC(memDC);

Цитата AndNot @ 11.12.06, 19:06

А есть еще 24-х и 16-ти битные. На них твой пример и загнется

Конечно, но для этого есть другая часть примера, я же сказал где посмотреть

Цитата AndNot @ 11.12.06, 19:06

Там еще и маски есть

Есть, но если ты знаешь формат, то можешь удивиться - с альфой они не используются

Цитата AndNot @ 11.12.06, 19:06

И на основании этого ты и сделал вывод что в bmiColors[] хранится цвет точек? Этот пример совершенно не показывает структуру BMP

Этот пример абсолютно наглядно показывает структуру 32-битных растров
Что еще имеем сказать?

Dmitry_177, вот загрузчик битмапов, по идее должен все загружать. Так проще разобраться, а то мы что то не в ту степь поперли

Type
  PSprite = ^TSprite;
  TSprite = record
    Width : Integer;
    Height: Integer;
    Buffer: ^Byte;
  end;
 
function ConvImage(ImgName: String): PSprite;
var
  Bitmap: TBitmap;
  Buff  : PSprite;
  Info  : TBitmapInfo;
  MemDC : HDC;
begin
  Bitmap := TBitmap.Create;
  Bitmap.LoadFromFile(ImgName);
// формируем заголовок
  with Info.bmiHeader do
    begin
      FillChar(Info, SizeOf(TBitmapInfo), 0);
      biSize := SizeOf(TBitmapInfoHeader);
      biWidth := Bitmap.Width;   // можешь поиграться с размерами
      biHeight := Bitmap.Height; // получаемого изображения
      biPlanes := 1;             // всегда 1
      biCompression := BI_RGB;   // нет никакой компрессии данных
      biBitCount := 24;          // пиксели будут в формате RGBTRIPLE
                                 // для RGBQUAD поставь 32
      GetMem(Buff, SizeOf(TSprite));
      Buff^.Width := biWidth;
      Buff^.Height:= biHeight;
      GetMem(Buff^.Buffer,(biWidth*biHeight) * (biBitCount shr 3));
      MemDC := CreateCompatibleDC(0);
      GetDIBits(MemDC,Bitmap.Handle, 0, biHeight, Buff^.Buffer, Info, DIB_RGB_COLORS);
      DeleteDC(MemDC);
    end;
  Bitmap.Free;
  ConvImage := Buff;
end.

Возвращает именно растр. Его формат указан в biBitCount.
Извини за возможные очепятки и некоторое несоответствие типов, дельфи в отказ пошел, похоже система последние дни доживает

Цитата Rouse_ @ 11.12.06, 19:45

с альфой они не используются

Да они вообще в принципе не нужны

Цитата Rouse_ @ 11.12.06, 19:45

Этот пример абсолютно наглядно показывает структуру 32-битных растров

Ладно завязываем. Разговор то поначалу пошел про поле bmiColors[].

Цитата AndNot @ 11.12.06, 19:53

Ладно завязываем. Разговор то поначалу пошел про поле bmiColors

Поддерживаю

Bitmap.LoadFromFile(ImgName);
...
biWidth := Bitmap.Width;   // можешь поиграться с размерами
biHeight := Bitmap.Height; // получаемого изображения

Это же битмап из модуля Graphics я как понял, а мне без него нужно...

Цитата Dmitry_177 @ 11.12.06, 20:52

Это же битмап из модуля Graphics я как понял, а мне без него нужно...

А это не важно. Главное получить хэндл загруженного в память битмапа. Например так:
Замени

  Bitmap: TBitmap;

на

  Bitmap: Handle; // или HWND

Затем загрузи его с помощью какой либо функции:
LoadBitmap - если из файла
LoadResource - из ресурсов
etc.
И полученный хендл передаешь вместо Bitmap.Handle;

а HBITMAP разве не хэндл? Загружаю его из файла:
hBkgnd := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

а как же быть с Bitmap.Width; Bitmap.Height;?

Цитата Dmitry_177 @ 11.12.06, 21:22

а HBITMAP разве не хэндл?

Извини, забыл сказать. Хэндлом может считаться любой DWORD.

Цитата Dmitry_177 @ 11.12.06, 21:22

Загружаю его из файла:
hBkgnd := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);

Почему бы и нет? А почему не хочешь LoadBitmap использовать?

Цитата Dmitry_177 @ 11.12.06, 21:22

а как же быть с Bitmap.Width; Bitmap.Height;?

Для определения ширины и высоты исходного битмапа вроде подходит функция GetBitmapDimensionEx(Handle: HBITMAP; var p: TPoint);

PS: Сообщи о результатах Я сам то еще не попробовал.

Так не работает почему-то...

var
  BmpSize: SIZE;
  hBmp: HBITMAP;
begin
  hBmp := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
  GetBitmapDimensionEx(hBmp, BmpSize);

BmpSize.cx и BmpSize.cy равны нулю...

>GetBitmapDimensionEx(hBmp, BmpSize);
>BmpSize.cx и BmpSize.cy равны нулю...
Так а какая ошибка возвращается от GetBitmapDimensionEx?
И загружается ли сам Битмап?

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

А вот так правильно определяются размеры, но только этот способ наверно медленнее чем с GetBitmapDimensionEx или нет?

var
  DIBS: DIBSECTION;
begin
  hBmp := LoadImage(0, '1.bmp', IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
 
  GetObject(hBmp, SizeOf(DIBS), @DIBS);
 
  W := DIBS.dsBm.bmWidth;
  H := DIBS.dsBm.bmHeight;
end;

Цитата Dmitry_177 @ 12.12.06, 13:01

BmpSize.cx и BmpSize.cy равны нулю...

Нда, в справе в самом конде есть замечательное примечание - она возвращает размер установленный с помощью SetBitmapDimensionEx. Так что не катит.

Цитата Dmitry_177 @ 12.12.06, 14:42

А вот так правильно определяются размеры, но только этот способ наверно медленнее чем с GetBitmapDimensionEx или нет?

Все равно ничего другого не остается Разве что самому считывать заголовок, но зачем, если он уже считан? Уж лучше так оставь.

Dmitry_177, верно, я именно так и делаю. Только не вздумай получать от туда BPP(bmBitsPixel)! Так как, как я уже писал она вернёт BPP текущего Device Context, а не то как записано в фаиле и не то, как вернётся из GetDIBits. Вот для этого уже придётся действительно читать Хеадер фаила.
Получив здесь не достающую мне информацию, я пришёл к выводу, что надо бы вообще написать отдельный модуль (свой) для работы с Битмапом. Как бы я не любил WinAPI, с битмапом там не всё так хорошо как хотелось бы.. (ИМХО).

Цитата WDaft @ 12.12.06, 21:09

Получив здесь не достающую мне информацию, я пришёл к выводу, что надо бы вообще написать отдельный модуль (свой) для работы с Битмапом.

Возможно именно поэтому в модуле graphics и используется чтение файла через BlockRead. А затем, после получения нужной инфы, подключаются апи.

Да, вероятно это именно так.
Хотя.. Может его как ни будь и использовать... как ни будь прикрутить. А то что велосипед изобретать.