imported>Unknown at 05:23, 7 February 2021

2021-02-07T05:23:58Z

New page

#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))
----
[[PNGFileFormat]]

PNGFileFormat/FormatUnitTestInPythonLanguage - Revision history

imported>Unknown at 05:23, 7 February 2021