denoising.py/code/BMPFile.readme

224 lines
5.5 KiB
Plaintext
Raw Normal View History

2015-10-05 16:07:59 +00:00
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] )