~cpp
#format python
#---------------- pngtest.py -------------------------------------------
# -*- coding: utf-8 -*-
import unittest
import zlib
import Image
import misc
from ThomPNG import *
class TestPngFormat(unittest.TestCase):
def setUp(self):
self.png = ThomPNG('tmp.png')
def tearDown(self):
self.png.close()
def testFirstEightBytes(self):
#eightBytesFromFile = self.png.firstEightBytes()
eightBytes = [137,80,78,71,13,10,26,10]
eightBytesFromFile = self.png.firstEightBytes()
for i in range(8):
self.assertEqual( chr(eightBytes[i]), eightBytesFromFile[i] )
def testChunkLength(self):
chunkInfo = self.png.nextChunk()
self.assertEqual(13, chunkInfo[0]) # 0 = chunkLen
def testImageIHDR(self):
im = Image.open(self.png.f.name)
chunkInfo = self.png.nextChunk()
# Width
imageWidth = ord(chunkInfo[2][0]) * (256**3)
imageWidth += ord(chunkInfo[2][1]) * (256**2)
imageWidth += ord(chunkInfo[2][2]) * (256**1)
imageWidth += ord(chunkInfo[2][3])
self.assertEqual(im.size[0], imageWidth)
# Height
imageHeight = ord(chunkInfo[2][4]) * (256**3)
imageHeight += ord(chunkInfo[2][5]) * (256**2)
imageHeight += ord(chunkInfo[2][6]) * (256**1)
imageHeight += ord(chunkInfo[2][7])
self.assertEqual(im.size[1], imageHeight)
# BitDepth
bitDepth = ord(chunkInfo[2][8])
self.assertEqual(True, bitDepth in [1,2,4,8,16])
# ColorType
colorType = ord(chunkInfo[2][9])
self.assertEqual(True, colorType in [0,2,3,4,6])
# CompressionMethod
compressionMethod = ord(chunkInfo[2][10])
# Filter Method
filterMethod = ord(chunkInfo[2][11])
# InterlaceMethod
interlaceMethod = ord(chunkInfo[2][12])
print '\nBitDepth, ColorType, CompressionMethod, FilterMethod = (%d, %d, %d, %d, %d)' \
% (bitDepth, colorType, compressionMethod, filterMethod, interlaceMethod)
def testImageDataSize(self):
self.png.nextChunk() # IHDR 부분 건너뛰기
totalSize = 0
loop=0
while True:
loop+=1
chunkInfo = self.png.nextChunk()
if chunkInfo[1] != 'IDAT':
self.assertEqual('IEND', chunkInfo[1])
self.assertEqual(0, chunkInfo[0])
break
totalSize += chunkInfo[0]
# 전체 파일 크기와 비교.
#self.assertEqual(224975, 8+4+4+13+4+(12*loop)+totalSize)
def testRGB(self):
rgb = RGB(1,1,1)
self.assertEqual((1,1,1), rgb)
# CRC 테스트
def testCRC(self):
chunkInfo = self.png.nextChunk()
fileCRC = chunkInfo[3]
computedCRC = self.png.computeCRC(chunkInfo[1]+chunkInfo[2])
expectedCRC = [(computedCRC&0xff000000)>>24,(computedCRC&0x00ff0000)>>16,(computedCRC&0x0000ff00)>>8,(computedCRC&0x000000ff)]
fileCRCInNum = [ord(fileCRC[0]), ord(fileCRC[1]), ord(fileCRC[2]), ord(fileCRC[3])]
self.assertEqual(expectedCRC, fileCRCInNum)
def testPaeth(self):
self.assertEqual(10, self.png.paethDictor(10,11,12))
self.assertEqual(87, self.png.paethDictor(0,87,0))
# PIL과 비교. scanline by scanline 으로 비교해야 한다.
def testCompareWithPIL(self):
im = Image.open(self.png.f.name)
zlibdata = self.png.getData()
base = [ord(zlibdata[1]), ord(zlibdata[2]), ord(zlibdata[3])]
rgbmap = []
for i in range(im.size[1]):
idx = self.png.getIdx(0,i)-1
scanline = self.png.makeScanline(base, i, zlibdata, rgbmap )
rgbmap.append(scanline)
self.assertTrue(len(rgbmap)>0)
for j in range(im.size[1]):
for i in range(im.size[0]) :
self.assertTrue(rgbmap[j][i].compare(im.getpixel((i,j)) ) )
if __name__=='__main__':
print '\n'
print '----------------------------------------'
print ' PNG Format TEST'
print '----------------------------------------'
print '\n'
unittest.main(argv=('', '-v'))
#---------------- ThomPNG.py -------------------------------------------
# -*- coding: utf-8 -*-
import Image
import zlib
class ThomPNG:
def __init__(self, filename):
self.f = file(filename, 'r')
self.leadingEightBytes = None
self.firstEightBytes()
self.crc = CRC()
self.data = None; self.width = None; self.height = None; self.bitDepth = None
def close(self):
self.f.close()
def firstEightBytes(self):
if self.leadingEightBytes == None:
self.leadingEightBytes = self.f.read(8)
return self.leadingEightBytes
def nextChunk(self):
buff = self.f.read(8)
chunkType = buff[4:]
chunkLen = ord(buff[0]) * (256 ** 3 )
chunkLen += ord(buff[1]) * (256 ** 2 )
chunkLen += ord(buff[2]) * (256)
chunkLen += ord(buff[3])
chunk = self.f.read(chunkLen)
if chunkType == 'IHDR':
self.makeInfo(chunk)
crc = self.f.read(4)
return [chunkLen, chunkType, chunk, crc]
def makeInfo(self, chunk): #width, height 등의 정보 얻기
# Width
self.width = ord(chunk[0]) * (256**3)
self.width += ord(chunk[1]) * (256**2)
self.width += ord(chunk[2]) * (256**1)
self.width += ord(chunk[3])
# Height
self.height = ord(chunk[4]) * (256**3)
self.height += ord(chunk[5]) * (256**2)
self.height += ord(chunk[6]) * (256**1)
self.height += ord(chunk[7])
def getData(self):
if self.data != None:
return self.data
self.nextChunk() # IHDR 읽기
# PLTE 등은 아직..
# ...
self.data = ''
while True:
chunks = self.nextChunk()
if chunks[1]!= 'IDAT':
break
self.data += chunks[2]
self.data = zlib.decompress(self.data)
return self.data
def computeCRC(self, buf):
return self.crc.getCRC(buf)
def makeScanline(self, basepixel, ypos, stream, rgbmap): # method 는 PNG filter type, stream은 zlib 으로 decomposite된 값들
idx = self.getIdx(0, ypos)-1
method = ord(stream[idx])
if method == 0:
pass
elif method == 1: # sub
return self.makeScanlineBySub(basepixel, ypos, stream)
elif method == 2:
return self.makeScanlineByUp(basepixel, ypos, stream, rgbmap)
elif method == 3:
return self.makeScanlineByAverage(basepixel, ypos, stream, rgbmap)
elif method == 4: #paeth
return self.makeScanlineByPaeth(basepixel, ypos, stream, rgbmap)
def makeScanlineBySub(self, basepixel, ypos, stream):
scanline = []
for i in range(self.width):
idx = self.getIdx(i, ypos)
filteredR = ord(stream[idx])
filteredG = ord(stream[idx+1])
filteredB = ord(stream[idx+2])
if i > 0 : # 인덱스가 0이 아닐 경우는 옆칸에서 더한다.
filteredR += scanline[i-1].r
filteredG += scanline[i-1].g
filteredB += scanline[i-1].b
rgbs = self.pureRGB(filteredR, filteredG, filteredB)
scanline.append(RGB(rgbs[0], rgbs[1], rgbs[2]) )
return scanline
def makeScanlineByUp(self, basepixel, ypos, stream, rgbmap):
scanline = []
for i in range(self.width):
idx = self.getIdx(i, ypos)
filteredR = ord(stream[idx])
filteredG = ord(stream[idx+1])
filteredB = ord(stream[idx+2])
if ypos > 0 : # y가 0 이면 윗칸에서 더할수 없지만 0보다 크면 더해야한다
filteredR += rgbmap[-1][i].r
filteredG += rgbmap[-1][i].g
filteredB += rgbmap[-1][i].b
rgbs = self.pureRGB(filteredR, filteredG, filteredB)
scanline.append(RGB(rgbs[0], rgbs[1], rgbs[2]) )
return scanline
def makeScanlineByAverage(self, basepixel, ypos, stream, rgbmap):
scanline = []
for i in range(self.width):
idx = self.getIdx(i, ypos)
filteredR = ord(stream[idx])
filteredG = ord(stream[idx+1])
filteredB = ord(stream[idx+2])
leftR = 0; leftG = 0; leftB = 0
upR = 0; upG = 0; upB = 0
if ypos > 0 :
upR = rgbmap[-1][i].r
upG = rgbmap[-1][i].g
upB = rgbmap[-1][i].b
if i > 0 :
leftR = scanline[i-1].r
leftG = scanline[i-1].g
leftB = scanline[i-1].b
filteredR += self.floor((leftR+upR)/2.0)
filteredG += self.floor((leftG+upG)/2.0)
filteredB += self.floor((leftB+upB)/2.0)
rgbs = self.pureRGB(filteredR, filteredG, filteredB)
scanline.append(RGB(rgbs[0], rgbs[1], rgbs[2]) )
return scanline
def makeScanlineByPaeth(self, basepixel, ypos, stream, rgbmap):
scanline = []
for i in range(self.width):
idx = self.getIdx(i, ypos)
filteredR = ord(stream[idx])
filteredG = ord(stream[idx+1])
filteredB = ord(stream[idx+2])
if i == 0 and ypos > 0 :
filteredR += self.paethDictor(0, rgbmap[-1][i].r, 0)
filteredG += self.paethDictor(0, rgbmap[-1][i].g, 0)
filteredB += self.paethDictor(0, rgbmap[-1][i].b, 0)
else:
if ypos == 0 :
filteredR += self.paethDictor(scanline[i-1].r, 0, 0)
filteredG += self.paethDictor(scanline[i-1].g, 0, 0)
filteredB += self.paethDictor(scanline[i-1].b, 0, 0)
else:
filteredR += self.paethDictor(scanline[i-1].r, rgbmap[-1][i].r, rgbmap[-1][i-1].r)
filteredG += self.paethDictor(scanline[i-1].g, rgbmap[-1][i].g, rgbmap[-1][i-1].g)
filteredB += self.paethDictor(scanline[i-1].b, rgbmap[-1][i].b, rgbmap[-1][i-1].b)
rgbs = self.pureRGB(filteredR, filteredG, filteredB)
scanline.append(RGB(rgbs[0], rgbs[1], rgbs[2]) )
return scanline
def pureRGB(self, r, g, b):
if r >= 256 : r -= 256
if g >= 256 : g -= 256
if b >= 256 : b -= 256
if r < 0 : r += 256
if g < 0 : g += 256
if b < 0 : b += 256
return (r, g, b)
def paethDictor(self, a, b, c):
p = a + b - c
pa = abs(p-a)
pb = abs(p-b)
pc = abs(p-c)
if pa<=pb and pa<=pc: return a
elif pb<=pc : return b
else : return c
def getIdx(self, x,y):
base = ( self.height * 3 * y ) + (y +1)
idx = base + 3 * x
return idx
def floor(self, x):
if x %1.0 == 0.0:
return int(round(x))
else:
return int(round(x+1))
class CRC:
def __init__(self):
self.crcTable = 0
self.makeCRCTable()
def makeCRCTable(self):
self.crcTable = [0L]*256
for i in range(256):
c = long(i)
for k in range(8):
if ( c & 1 ) :
c = 0xedb88320L ^ (c>>1)
else :
c = c >> 1
self.crcTable[i] = c
def updateCRC(self, buf):
c = 0xFFFFFFFFL
for ch in buf:
#c = crcTable[(c ^ ord(ch) ) & 0xff] ^ (c >> 8)
c = self.crcTable[int ((c^ord(ch))&0xff) ] ^ (c >> 8)
return long(c)
def getCRC(self, buf):
return long(self.updateCRC(buf) ^ 0xFFFFFFFFL )
class RGB:
def __init__(self, r, g, b):
self.r = r
self.g = g
self.b = b
def compare(self, rgb):
return self.r == rgb[0] and self.g == rgb[1] and self.b == rgb[2]
def __eq__(self, rgb):
return self.compare(rgb)
def __str__(self):
return str((self.r, self.g, self.b))