Klemek
120 lines
4.8 KiB
Python
Executable File
120 lines
4.8 KiB
Python
Executable File
from typing import Tuple
|
|
|
|
|
|
class BitmapError(Exception):
|
|
pass
|
|
|
|
|
|
class Bitmap:
|
|
HEADER_SIZE = 54
|
|
FILE_TYPES = [("Bitmap Image", "*.bmp"), ("All Files", "*.*")]
|
|
|
|
@classmethod
|
|
def write_bmp(cls, path: str, width: int, color_depth: int, data: bytes) -> None:
|
|
with open(path, mode="wb") as f:
|
|
f.write(cls.__get_bmp_data(width, color_depth, data))
|
|
|
|
@classmethod
|
|
def __get_bmp_data(cls, width: int, color_depth: int, data: bytes) -> bytes:
|
|
height = len(data) // (width * 3)
|
|
return cls.__get_header(
|
|
width, height, color_depth, len(data)
|
|
) + cls.__format_data(width, height, color_depth, data)
|
|
|
|
@classmethod
|
|
def __get_header(
|
|
cls, width: int, height: int, color_depth: int, data_len: int
|
|
) -> bytes:
|
|
header = bytes()
|
|
# BMP header
|
|
header += "BM".encode() # (0, 2) BM
|
|
header += (cls.HEADER_SIZE + data_len).to_bytes(
|
|
4, byteorder="little"
|
|
) # (2, 4) file size
|
|
header += bytes([0]) * 4 # (6, 4) application reserved
|
|
header += (cls.HEADER_SIZE).to_bytes(
|
|
4, byteorder="little"
|
|
) # (10, 4) data offset
|
|
# DIB header
|
|
header += (40).to_bytes(4, byteorder="little") # (14, 4) DIB header size
|
|
header += width.to_bytes(4, byteorder="little") # (18, 4) width
|
|
header += height.to_bytes(4, byteorder="little") # (22, 4) height
|
|
header += (1).to_bytes(2, byteorder="little") # (26, 2) color panes
|
|
header += (color_depth * 8).to_bytes(
|
|
2, byteorder="little"
|
|
) # (28, 2) bits per pixel
|
|
header += bytes([0]) * 4 # (30, 4) BI_RGB, no compression
|
|
header += (data_len).to_bytes(
|
|
4, byteorder="little"
|
|
) # (34, 4) size of raw bitmap data
|
|
header += (2835).to_bytes(
|
|
4, byteorder="little"
|
|
) # (38, 4) horizontal print resolution
|
|
header += (2835).to_bytes(
|
|
4, byteorder="little"
|
|
) # (42, 4) vertical print resolution
|
|
header += bytes([0]) * 4 # (46, 4) color in palette
|
|
header += bytes([0]) * 4 # (50, 4) 0 important colors
|
|
return header
|
|
|
|
@classmethod
|
|
def __format_data(
|
|
cls, width: int, height: int, color_depth: int, data: bytes
|
|
) -> bytes:
|
|
size = width * height * color_depth
|
|
if len(data) < size:
|
|
data += bytes([0]) * (size - len(data))
|
|
elif len(data) > size:
|
|
data = data[:size]
|
|
line_padding = (width * color_depth) % 4
|
|
output_data = bytes()
|
|
for y in range(height):
|
|
start = (height - y - 1) * color_depth * width
|
|
output_data += data[start : start + width * color_depth]
|
|
if line_padding > 0:
|
|
output_data += bytes([0]) * (4 - line_padding)
|
|
return output_data
|
|
|
|
@classmethod
|
|
def read_bmp(cls, path: str) -> Tuple[int, int, int, bytes]:
|
|
with open(path, mode="rb") as f:
|
|
bmp_data = f.read()
|
|
width, height, color_depth, data_start, data_size = cls.__read_header(bmp_data)
|
|
content_data = bmp_data[data_start:]
|
|
if data_size > 0:
|
|
content_data = content_data[:data_size]
|
|
output_data = cls.__read_formated_data(width, height, color_depth, content_data)
|
|
return width, height, color_depth, output_data
|
|
|
|
@classmethod
|
|
def __read_header(cls, bmp_data: bytes) -> Tuple[int, int, int, int, int]:
|
|
if bmp_data[0:2].decode() != "BM":
|
|
raise BitmapError("Not a Bitmap Image")
|
|
if int.from_bytes(bmp_data[30:34], byteorder="little") != 0:
|
|
raise BitmapError("Cannot read Bitmap: need no compression")
|
|
if int.from_bytes(bmp_data[26:28], byteorder="little") != 1:
|
|
raise BitmapError("Cannot read Bitmap: need 1 color panes")
|
|
width = int.from_bytes(bmp_data[18:22], byteorder="little")
|
|
height = int.from_bytes(bmp_data[22:26], byteorder="little")
|
|
color_depth = int.from_bytes(bmp_data[28:30], byteorder="little") // 8
|
|
if color_depth < 1:
|
|
raise BitmapError("Cannot read Bitmap: bits per pixels is < 8")
|
|
data_start = int.from_bytes(bmp_data[10:14], byteorder="little")
|
|
data_size = int.from_bytes(bmp_data[34:38], byteorder="little")
|
|
return width, height, color_depth, data_start, data_size
|
|
|
|
@classmethod
|
|
def __read_formated_data(
|
|
cls, width: int, height: int, color_depth: int, bmp_data: bytes
|
|
) -> bytes:
|
|
line_padding = (width * color_depth) % 4
|
|
if line_padding > 0:
|
|
real_width = width * color_depth + (4 - line_padding)
|
|
else:
|
|
real_width = width * color_depth
|
|
output_data = bytes()
|
|
for y in range(height):
|
|
start = (height - y - 1) * real_width
|
|
output_data += bmp_data[start : start + width * color_depth]
|
|
return output_data
|