BMPContent unparse créé le header (via handler) et la création d'une image manuellement (par création de la map uniquement) fonctionne et créée bien un fichier viable

code/bmp.py

@@ -5,35 +5,53 @@
 
 # classes
 from classes import *
-
+import random
 import sys
 
-# lecture du fichier
-with open( sys.argv[1] ) as file:
-	binFile = file.read()
 
-# Instanciation du BMPFile
+def testFileIntegrity():
-img = BMPFile()
+	# lecture du fichier
+	with open( sys.argv[1] ) as file:
+		binFile = file.read()
 
-# Parsing
+	# Instanciation du BMPFile
-img.parse( binFile );
+	img = BMPFile()
+
+	# Parsing
+	img.parse( binFile );
+
+	# MODIFICATIONS des pixels
+	for line in img.content.map:
+		for pixel in line:
+			pixel.r = 255
+			pixel.g = 75
+			pixel.b = 255
 
 
-# MODIFICATIONS des pixels
+	# Unparsing
-for line in img.content.map:
+	img.unparse()
-	for pixel in line:
-		pixel.r = 255
-		pixel.g = 75
-		pixel.b = 255
 
 
-# Unparsing
+	print img.binData
-img.unparse()
 
 
-print img.binData
 
-# for line in img.content.map:
+
-# 	for pixel in line:
+
-# 		print "rgb(%s, %s, %s)" % (pixel.r, pixel.g, pixel.b)
+def testManualCreation():
-# 	print
+	img = BMPFile()
+	for y in range(0, 100):
+		img.content.map.append( [] )
+		for x in range(0, 100):
+			img.content.map[y].append( RGBPixel(
+				random.randint(0, 255),
+				random.randint(0, 255),
+				random.randint(0, 255)
+			) );
+
+	img.unparse();
+
+	print img.binData
+
+# MAIN
+testManualCreation()

code/bmp.readme

@@ -74,8 +74,8 @@ Classes:
 		parse(binContent="", header):
 			Définit les attributs à partir de <binData> ou de l'argument <binContent> si défini ainsi que du header
 			
-		unparse():
+		unparse(headerHandler=None):
-			Définit <bin> à partir map
+			Définit <bin> à partir map et définit aussi l'objet <headerHandler> s'il est passé en paramètres
 
 
 
@@ -129,3 +129,18 @@ Classes:
 		Constructeur(r, g, b):
 			Définit les attributs
 
+
+
+
+
+
+
+
+
+
+
+
+#############
+##  To Do  ##
+#############
+[x] faire que le unparse du content créée le header

code/classes.py

@@ -91,6 +91,10 @@ class BMPHeader:
 		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:
@@ -128,7 +132,7 @@ class BMPHeader:
 		print "INFORMATIONS COMP."
 		print "====================="
 		print "rowsize:           %s" % displayType( self.rowSize   ) 
-		print "rowEncoded:        %s" % displayType( self.padding   ) 
+		print "padding:           %s" % displayType( self.padding   ) 
 		print "====================="
 		print
 
@@ -163,7 +167,7 @@ class BMPContent:
 	def __init__(self):
 		self.map = []
 		self.binData = ""
-		self.readableData = ""
+		self.intData = []
 
 	# parse le content (bin) <binContent> avec les informations:
 	#	<header>	BMPHeader de l'image en question
@@ -212,19 +216,37 @@ class BMPContent:
 
 
 	# unparse une map de pixels en binaire
-	def unparse(self, map):
+	def unparse(self, map, headerHandler=None):
 		self.map = map
 		
-		height  = len( map    ) # nb de lignes   = taille de la map
+		if not isinstance(headerHandler, BMPHeader):
-		width   = len( map[0] ) # nb de colonnes = taille des lignes de la map
+			headerHandler = BMPHeader()
-		padding = ( 4 - width*3 % 4 ) % 4 # padding de bourrage de lignes
 		
 
+		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 <map>
+		headerHandler.height    = len( map    )      # récupérée à partir de l'argument <map>
+		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.b) + chr(pixel.g) + chr(pixel.r)
-			for zero in range(0, padding):
+			for zero in range(0, headerHandler.padding):
 				self.binData += chr(0)
 
 		self.intData = []
@@ -248,6 +270,15 @@ class RGBPixel:
 ####################################################
 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 <binFile> en objets <BMPHeader> et <BMPContent>
 	def parse(self, binFile=""):
 		# si on a défini le fichier
@@ -288,7 +319,7 @@ class BMPFile:
 			self.binPalette += chr(byte)
 
 		# on déparse les classes utilisées
-		self.content.unparse( self.content.map )
+		self.content.unparse( self.content.map, self.header )
 		self.header.unparse()
 
 		# on enregistre le contenu brut binaire du fichier complet