# ~*~ encoding: utf-8 ~*~ # ################################################# # classe qui parse le header (binaire) en objet # ################################################# class BMPHeader: # CONSTRUCTEUR: initialise les variables def __init__(self): self.binData = 0; # header brut (format initial: bin) self.intData = 0; # header brut (format entier) self.hexData = 0; # header brut (format hexadécimal) self.signature = 0; # signature (4D42) self.fileSize = 0; # taille du fichier bmp (bytes) self.offset = 0; # début de l'image (bytes) self.infoSize = 0; # taille du INFO_HEADER self.width = 0; # longueur de l'image (pixel) self.height = 0; # hauteur de l'image (pixel) self.plans = 0; # nombre de plans (default: 1) self.bpp = 0; # nombre de bits par pixel (1,4,8, 24) self.compType = 0; # type de compression (0=none, 1=RLE-8, 2=RLE-4) self.size = 0; # taille de l'image avec padding (bytes) self.horiRes = 0; # résolution horizontale (pixels) self.vertRes = 0; # résolution verticale (pixels) self.colorNb = 0; # nombre de couleurs de l'image (ou 0) self.colorINb = 0; # nombre d'images importantes (ou 0) self.rowSize = 0; # longueur réelle d'une ligne self.padding = 0; # bourrage de fin de ligne (nb de bytes) # parse le header au format bin en objet def parse(self, binHeader=""): # on utilise l'argument si on l'a sinon l'attribut if binHeader != "": parsingData = binHeader else: parsingData = self.binData self.binData = parsingData # header brut (format initial: bin) self.signature = self.toInt( parsingData[ 0: 2] ) # signature (4D42) self.fileSize = self.toInt( parsingData[ 2: 6] ) # taille du fichier bmp (bytes) # 4 empty bytes (empty value = 0) self.offset = self.toInt( parsingData[10:14] ) # début de l'image (bytes) self.infoSize = self.toInt( parsingData[14:18] ) # taille du INFO_HEADER self.width = self.toInt( parsingData[18:22] ) # longueur de l'image (pixel) self.height = self.toInt( parsingData[22:26] ) # hauteur de l'image (pixel) self.plans = self.toInt( parsingData[26:28] ) # nombre de plans (default: 1) self.bpp = self.toInt( parsingData[28:30] ) # nombre de bits par pixel (1,4,8, 24) self.compType = self.toInt( parsingData[30:34] ) # type de compression (0=none, 1=RLE-8, 2=RLE-4) self.size = self.toInt( parsingData[34:38] ) # taille de l'image avec padding (bytes) self.horiRes = self.toInt( parsingData[38:42] ) # résolution horizontale (pixels) self.vertRes = self.toInt( parsingData[42:46] ) # résolution verticale (pixels) self.colorNb = self.toInt( parsingData[46:50] ) # nombre de couleurs de l'image (ou 0) self.colorINb = self.toInt( parsingData[50:54] ) # nombre de couleurs importantes de l'images (ou 0) # calculated values self.rowSize = self.size / self.height # taille réelle d'une ligne (+padding) self.padding = self.rowSize - self.width*self.bpp/8 # bourrage (nb de bytes) self.intData = [] for byte in parsingData: self.intData.append( ord(byte) ) # fonction qui créer à partir des attributs def unparse(self): # on définit le tableau d'entier à partir des attributs self.intData = [] self.fromInt( self.signature, 2) # signature self.fromInt( self.fileSize, 4) # taille fichier BMP self.fromInt( 0, 4) # 4 bytes inutilisés self.fromInt( self.offset, 4) # début de l'image (bytes) self.fromInt( self.infoSize, 4) # taille du INFO_HEADER self.fromInt( self.width, 4) # longueur de l'image (pixels) self.fromInt( self.height, 4) # hauteur de l'image (pixels) self.fromInt( self.plans, 2) # nombre de plans (default: 1) self.fromInt( self.bpp, 2) # nombre de bits par pixel (1,4,8, 24) self.fromInt( self.compType, 4) # type de compression self.fromInt( self.size, 4) # taille de la map (matrice de pixels) self.fromInt( self.horiRes, 4) # résolution horizontale self.fromInt( self.vertRes, 4) # résolution verticale self.fromInt( self.colorNb, 4) # nombre de couleurs de l'image (ou 0) self.fromInt( self.colorINb, 4) # nombre de couleurs importantes de l'image (ou 0) # calculated values self.rowSize = self.size / self.height # taille réelle d'une ligne (+padding) self.padding = self.rowSize - self.width*self.bpp/8 # bourrage (nb de bytes) self.binData = "" for byte in self.intData: self.binData += chr( byte ) # Affiche au format humain, toutes les infos du header def info(self, type=0): # 0 = int, 1 = hex if type == 0: # si int def displayType(value): return value else: def displayType(value): return hex(value) print print "INFORMATION DU HEADER" print "=====================" print "signature: %s" % displayType( self.signature ) print "taille du fichier: %s" % displayType( self.fileSize ) print "offset du contenu: %s" % displayType( self.offset ) print "taille infoHeader: %s" % displayType( self.infoSize ) print "largeur: %s" % displayType( self.width ) print "hauteur: %s" % displayType( self.height ) print "nombre de plans: %s" % displayType( self.plans ) print "bits par pixel: %s" % displayType( self.bpp ) print "type compression: %s" % displayType( self.compType ) print "taille(+padding): %s" % displayType( self.size ) print "horizontal resol: %s" % displayType( self.horiRes ) print "vertical resol: %s" % displayType( self.vertRes ) print "nombre de couleur: %s" % displayType( self.colorNb ) print "nb couleurs impor: %s" % displayType( self.colorINb ) print "=====================" print "INFORMATIONS COMP." print "=====================" print "rowsize: %s" % displayType( self.rowSize ) print "padding: %s" % displayType( self.padding ) print "=====================" print # convertit les octets en entier def toInt(self, bytes): intReturn = 0; for i, byte in enumerate(bytes): intReturn += ord(byte) * (256 ** i) return intReturn # écrit le valeur entière en octet bourrés jusqu'à la taille dans le tableau def fromInt(self, value, size): s = '0' + str( bin(value)[2:] ) for byte in range(0, size): if s=="": self.intData.append( 0 ) else: self.intData.append( int(s[-8:],2) ) s = s[:-8] #################################################### # classe qui parse le content (binaire) en matrice # #################################################### class BMPContent: # CONSTRUCTEUR: instancie les attribus def __init__(self): self.map = [] self.binData = "" self.intData = [] # parse le content (bin) avec les informations: #
BMPHeader de l'image en question def parse(self, binContent, header): # gestion du bpp if( header.bpp != 24 ): print "Ne prends pas en charge les versions autre que bmp24"; exit() # taille avec un padding de 1 correctSize = header.rowSize * header.height; # si le fichier a une mauvaise taille donc mauvais format if not len(binContent) == correctSize: print "Mauvais format (erreur de taille)" exit() # attribution de la map self.map = [] i = 0 for line in range(0, header.height): self.map.append( [] ) # on créé la colonne for pix in range(0, header.width): self.map[line].append( # on ajoute le pixel à la ligne RGBPixel( ord( binContent[i+2] ), # rouge ord( binContent[i+1] ), # vert ord( binContent[i+0] ) # bleu ) ); i += 3 # on passe à la suite i += header.padding # on saute le padding de saut de ligne self.map = self.map[::-1] # on inverse les lignes self.binData = binContent # human-readable data self.intData = [] for byte in self.binData: self.intData.append( ord( byte ) ) # unparse une map de pixels en binaire def unparse(self, map, headerHandler=None): self.map = map if not isinstance(headerHandler, BMPHeader): headerHandler = BMPHeader() headerHandler.signature = int( 0x4D42 ) headerHandler.offset = 54 + 68 # taille header(54) + taille palette(68) headerHandler.infoSize = headerHandler.offset - 14 # valeur d'offset - 14 headerHandler.width = len( map[0] ) # récupérée à partir de l'argument headerHandler.height = len( map ) # récupérée à partir de l'argument headerHandler.plans = 1 headerHandler.bpp = 24 headerHandler.compType = 0 headerHandler.horiRes = int( 0xB13 ) headerHandler.vertRes = int( 0xB13 ) headerHandler.colorNb = 0 headerHandler.colorINb = 0 # valeurs calculées headerHandler.padding = ( 4 - headerHandler.width*3 % 4 ) % 4 headerHandler.size = headerHandler.width * headerHandler.height * headerHandler.bpp # taille de la map (hauteur*largeur* nombre d'octets par pixel) headerHandler.rowSize = headerHandler.size / headerHandler.height # taille réelle de ligne headerHandler.fileSize = headerHandler.offset + headerHandler.size # taille du fichier BMP = offset + taille map self.binData = "" for line in self.map[::-1]: for pixel in line: self.binData += chr(pixel.binData) for zero in range(0, headerHandler.padding): self.binData += chr(0) self.intData = [] for byte in self.binData: self.intData.append( ord(byte) ) ################################# # classe contenant un pixel RGB # ################################# class RGBPixel: def __init__(self, r, g, b, bpp=24): if bpp not in [1,4,8,24]: self.bpp = 24 else: self.bpp = bpp self.r = r self.g = g self.b = b # gestion des différents bpp if bpp == 1: self.intData = [ int( (r+g+b)/3 > 256/2 ) ] self.binData = chr( self.intData ) elif bpp == 4: self.intData = [ int( 16 * ((r+g+b)/3) / 256 ) ] self.binData = chr( self.intData ) elif bpp == 8: self.intData = [ int( (r+g+b) / 3 ) ] self.binData = chr( self.intData ) else: self.intData = [ r, g, b ] self.binData = chr(b) + chr(g) + chr(r) def setRGB(self, r, g, b, bpp=24): self.__init__(r, g, b, bpp); def setBin(self, binData, bpp=24): if bpp not in [1,4,8,24]: self.bpp = 24 else: self.bpp = bpp # gestion des différents bpp if bpp == 1: self.intData = [ 255 * int(binData) ] self.r = self.intData[0] self.g = self.intData[0] self.b = self.intData[0] elif bpp == 4: self.intData = [ 256 * ord(binData) / 16 ] self.r = self.intData[0] self.g = self.intData[0] self.b = self.intData[0] elif bpp == 8: self.intData = [ ord(binData) ] self.r = self.intData[0] self.g = self.intData[0] self.b = self.intData[0] else: self.intData = [ ord(binData[2]), ord(binData[1]), ord(binData[0]) ] self.r = self.intData[0] self.g = self.intData[1] self.b = self.intData[2] self.r = r self.g = g self.b = b #################################################### # classe qui parse un fichier BMP complet en objet # #################################################### class BMPFile: # CONSTRUCTEUR: instancie les attributs def __init__(self): self.header = BMPHeader() self.content = BMPContent() self.binData = "" self.intData = [] self.binPalette = "" self.intPalette = [] # parse à partir de en objets et def parse(self, binFile=""): # si on a défini le fichier if binFile == "": print " need an argument" exit() # human-readable data self.binData = binFile self.intData = [] for byte in binFile: self.intData.append( ord(byte) ) headerSize = 54 # parsing header self.header = BMPHeader() self.header.parse( self.binData[:headerSize] ) # parsing content self.content = BMPContent() self.content.parse( self.binData[self.header.offset:], self.header ) # création de la pallette (header complémentaire=définition des couleurs+codage) self.binPalette = self.binData[54:self.header.offset] self.intPalette = [] for byte in self.binPalette: self.intPalette.append( ord(byte) ) # unparse à partir d'un et d'un def unparse(self): # on définit la palette par défaut self.intPalette = [66, 71, 82, 115, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] self.binPalette = "" for byte in self.intPalette: self.binPalette += chr(byte) # on déparse les classes utilisées self.content.unparse( self.content.map, self.header ) self.header.unparse() # on enregistre le contenu brut binaire du fichier complet self.binData = "%s%s%s" % (self.header.binData, self.binPalette, self.content.binData) self.intData = [] for byte in self.binData: self.intData.append( ord(byte) )