denoising.py/code/BMPFile.readme

Classes:

	BMPHeader
		/***************/
		/*  ATTRIBUTS  */
		/***************/

		* CONTENU BRUT PARTIEL (54 premiers bytes)
			- <binData>			header brut (binaire)
			- <intData>			header format liste de (0-255)

		* STRUCTURE DU HEADER
			- <signature>		signature (4D42) par défaut
			- <fileSize>		taille du fichier .bmp (bytes)
								4 bytes à 0
			- <offset>			début du codage de l'image (bytes)		
			- <infoSize>		taille du INFO_HEADER
			- <width>			longueur de l'image (pixels)
			- <height>			hauteur de l'image (pixels)
			- <plans>			nombre de plans (défaut: 1)
			- <bpp>				nombre de bits par pixel (1,4,8,24)
			- <compType>		type de compression (0=none, 1=RLE-8, 2=RLE-4)
			- <size>			taille de l'image avec padding (bytes)
			- <horiRes>			résolution horizontale (pixels)
			- <vertRes>			résolution verticale (pixels)
			- <colorNb>			nombre de couleurs de l'image (ou 0)
			- <colorINb>		nombre de couleurs importantes de l'image (ou 0)
		
		* VALEURS CALCULEES
			- <rowSize>			taille réelle d'une ligne +padding (bytes)
			- <padding>			taille du padding de fin de ligne (bytes)

		/***************/
		/*  METHODES   */
		/***************/
		parse(binHeader=""):
			Définit les attributs à partir de <binData> ou de l'argument <binHeader> si défini
			
		unparse():
			Définit <binData>, et <intData> à partir de tout les attributs de structure


		info(type=0):
			Affiche les informations du header au format humain
			<type> peut valoir 0 (valeur par défaut) pour afficher en nombre, ou 1 pour afficher en hexa


		toInt(bytes):
			Retourne les octets <bytes> sous forme d'entier

		fromInt(value, size):
			Retourne une chaine de <size> bytes correspondant au binaire de value





	BMPContent
		/***************/
		/*  ATTRIBUTS  */
		/***************/

		* CONTENU BRUT
			- <binData>			matrice de pixels brut (binaire)
			- <intData>			matrice de pixels format liste de (0-255)

		* CONTENU EXPLOITABLE
			- <map>				matrice de pixels (instance of RGBPixel)


		/***************/
		/*  METHODES   */
		/***************/
		parse(binContent="", header):
			Définit les attributs à partir de <binData> ou de l'argument <binContent> si défini ainsi que du header
			
		unparse(headerHandler=None):
			Définit <bin> à partir map et définit aussi l'objet <headerHandler> s'il est passé en paramètres





	BMPFile
		/***************/
		/*  ATTRIBUTS  */
		/***************/
		* CONTENU PALETTE (fin du header jusqu'aux pixels)
			- <binPalette>		palette format binaire (header à offset)
			- <intPalette>		palette format list de (0-255)
		
		* CONTENU BRUT
			- <binData>			contenu complet brut (binaire)
			- <intData>			contenu complet format liste de (0-255)

		* CONTENU STRUCTURE
			- <header>			objet de type <BMPHeader>
			- <content>			objet de type <BMPContent>


		/***************/
		/*  METHODES   */
		/***************/
		parse(binFile=""):
			Définit les attributs à partir de <binData> ou de l'argument <binFile> si défini
			
		unparse():
			Définit <binData> à partir des attributs <BMPHeader> et <BMPContent>








	RGBPixel
		/***************/
		/*  ATTRIBUTS  */
		/***************/
		- <r>					byte rouge entre 0 et 255
		- <g>					byte vert entre 0 et 255
		- <b>					byte bleu entre 0 et 255


		/***************/
		/*  METHODES   */
		/***************/
		Constructeur(r, g, b):
			Définit les attributs












#############
##  To Do  ##
#############
[x] gestion de la palette (attribut au <parse>) définit par défaut au <unparse>
[x] faire que le unparse du content créée le header
[ ] prise en charge des formats 1, 4, et 8 bpp



#######################################################################
####### RECHERCHE DE PRISE EN CHARGE DES DIFFERENTS FORMATS BPP #######
#######################################################################
PixelColor(r, g, b, bpp=24)
	<r>, <g>, <b>	respectivement les composantes bleue, rouge, verte
	<bpp>			correspond aux bpp

CAS BPP=1 (noir et blanc)
	(r+g+b)/3 >= 256 / 2

	1 - blanc
	2 - noir

CAS BPP=4 (niveaux de gris)
	16 * ((r+g+b)/3) / 256

CAS BPP=8
	(r+g+b) / 3

class PixelColor(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.intColor = int( (r+g+b)/3 > 256/2 )
		self.binColor = chr( self.intColor )
	elif bpp == 4:
		self.intColor = int( 16 * ((r+g+b)/3) / 256 ) )
		self.binColor = chr( self.intColor )
	elif bpp == 8:
		self.intColor = int( (r+g+b) / 3 )
		self.binColor = chr( self.intColor )
	else:
		self.intColor = [r, g, b]
		self.binColor = chr(b) + chr(g) + chr(r)



#######################################################################
#######   RECHERCHE DE PARSAGE DES PIXELS DE DIFFERENTS BPPS    #######
#######################################################################
ALGO:


firstBit = int(i) + i%1.0; # retourne le rang du premier bit (pas byte)
lastBit = firstBit + bpp/8.0

startByte = int( firstBit )                   # ex: pour i =29, on a: 3 octets
startBit  = int( 8 * (firstBit-startByte) )   #                       et 5 bits

stopByte  = int( lastBit )
stopBit   = int( 8 * (lastBit-stopByte) )

bytes = binData[startByte:stopByte+1]

intArray = [ ord(x) for x in bytes ]
binArray = [ "0" + bin(x)[2:] for x in intArray ]
binArray = [ "0"*(8-len(binArray[x])) + binArray[x] for x in range(0, len(binArray)) ]
binary = ""
for byte in binArray:
	binary += byte;

print binArray
print "%s to %s => %s" % ( startBit, 8*(stopByte-startByte)+stopBit, binary[startBit:8*(stopByte-startByte) + stopBit] )