def read_flow_png(flow_file):
"""
Read optical flow from KITTI .png file
:param flow_file: name of the flow file
:return: optical flow data in matrix
"""
flow_object = png.Reader(filename=flow_file)
flow_direct = flow_object.asDirect()
flow_data = list(flow_direct[2])
(w, h) = flow_direct[3]['size']
flow = np.zeros((h, w, 3), dtype=np.float64)
for i in range(len(flow_data)):
flow[i, :, 0] = flow_data[i][0::3]
flow[i, :, 1] = flow_data[i][1::3]
flow[i, :, 2] = flow_data[i][2::3]
invalid_idx = (flow[:, :, 2] == 0)
flow[:, :, 0:2] = (flow[:, :, 0:2] - 2 ** 15) / 64.0
flow[invalid_idx, 0] = 0
flow[invalid_idx, 1] = 0
return flow
python类Reader()的实例源码
def read_disp_png(file_name):
"""
Read optical flow from KITTI .png file
:param file_name: name of the flow file
:return: optical flow data in matrix
"""
image_object = png.Reader(filename=file_name)
image_direct = image_object.asDirect()
image_data = list(image_direct[2])
(w, h) = image_direct[3]['size']
channel = len(image_data[0]) / w
flow = np.zeros((h, w, channel), dtype=np.uint16)
for i in range(len(image_data)):
for j in range(channel):
flow[i, :, j] = image_data[i][j::channel]
return flow[:, :, 0] / 256
def load(filename):
'''Carica l'immagine in formato PNG dal file filename, la converte nel
formato a matrice di tuple e la ritorna'''
with open(filename,'rb') as f:
# legge l'immagine come RGB a 256 valori tramite l'oggetto Reader
iw, ih, png_img, _ = png.Reader(file=f).asRGB8()
# converte l'immagine in lista di liste di tuple
img = []
for png_row in png_img:
row = []
# l'immagine PNG ha i colori come un unico array
# quindi li leggiamo tre alla volta e impacchettiamo in una tupla
for i in range(0,len(png_row),3):
row.append( (png_row[i+0],png_row[i+1],png_row[i+2]) )
img.append( row )
return img
def load(filename):
'''Carica l'immagine in formato PNG dal file
filename, la converte nel formato a matrice
di tuple e la ritorna'''
with open(filename,'rb') as f:
# legge l'immagine come RGB a 256 valori
r = png.Reader(file=f)
iw, ih, png_img, _ = r.asRGB8()
# converte in lista di liste di tuple
img = []
for png_row in png_img:
row = []
# l'immagine PNG ha i colori in
# un'unico array quindi li leggiamo
# tre alla volta in una tupla
for i in range(0,len(png_row),3):
row.append( ( png_row[i+0],
png_row[i+1],
png_row[i+2] ) )
img.append( row )
return img
def flow_read_png(fpath):
"""
Read KITTI optical flow, returns u,v,valid mask
"""
if not has_png:
print('Error. Please install the PyPNG library')
return
R = png.Reader(fpath)
width,height,data,_ = R.asDirect()
I = np.array(map(lambda x:x,data)).reshape((height,width,3))
u_ = I[:,:,0]
v_ = I[:,:,1]
valid = I[:,:,2]
u = (u_.astype('float64')-2**15)/64.0
v = (v_.astype('float64')-2**15)/64.0
return u,v,valid
def load_sprite_from_png(self, filename, addr):
logging.debug("VRAM: Loading %s at %x", filename, addr)
reader = png.Reader(filename=filename)
pic = reader.read()
self.set_vram_cursor(addr)
for line in pic[2]:
i = 0
word = 0
for px in line:
word |= px << i
i += pic[3]['bitdepth']
if i > 7:
self.write_vram(None, word)
i = 0
word = 0
def read_disp_png(disp_file):
"""
Read kitti disp from .png file
:param disp_file:
:return:
"""
image_object = png.Reader(filename=disp_file)
image_direct = image_object.asDirect()
image_data = list(image_direct[2])
(w, h) = image_direct[3]['size']
channel = len(image_data[0]) / w
disp = np.zeros((h, w, channel), dtype=np.uint16)
for i in range(len(image_data)):
for j in range(channel):
disp[i, :, j] = image_data[i][j::channel]
return disp[:, :, 0] / 256
# TODO: function flow_write(flow_file)
def read_disp_png(file_name):
"""
Read optical flow from KITTI .png file
:param file_name: name of the flow file
:return: optical flow data in matrix
"""
image_object = png.Reader(filename=file_name)
image_direct = image_object.asDirect()
image_data = list(image_direct[2])
(w, h) = image_direct[3]['size']
channel = len(image_data[0]) / w
flow = np.zeros((h, w, channel), dtype=np.uint16)
for i in range(len(image_data)):
for j in range(channel):
flow[i, :, j] = image_data[i][j::channel]
return flow[:, :, 0] / 256
def read_png_file(flow_file):
"""
Read from KITTI .png file
:param flow_file: name of the flow file
:return: optical flow data in matrix
"""
flow_object = png.Reader(filename=flow_file)
flow_direct = flow_object.asDirect()
flow_data = list(flow_direct[2])
(w, h) = flow_direct[3]['size']
print "Reading %d x %d flow file in .png format" % (h, w)
flow = np.zeros((h, w, 3), dtype=np.float64)
for i in range(len(flow_data)):
flow[i, :, 0] = flow_data[i][0::3]
flow[i, :, 1] = flow_data[i][1::3]
flow[i, :, 2] = flow_data[i][2::3]
invalid_idx = (flow[:, :, 2] == 0)
flow[:, :, 0:2] = (flow[:, :, 0:2] - 2 ** 15) / 64.0
flow[invalid_idx, 0] = 0
flow[invalid_idx, 1] = 0
return flow
def read_disp_png(disp_file):
"""
Read kitti disp from .png file
:param disp_file:
:return:
"""
image_object = png.Reader(filename=disp_file)
image_direct = image_object.asDirect()
image_data = list(image_direct[2])
(w, h) = image_direct[3]['size']
channel = len(image_data[0]) / w
disp = np.zeros((h, w, channel), dtype=np.uint16)
for i in range(len(image_data)):
for j in range(channel):
disp[i, :, j] = image_data[i][j::channel]
return disp[:, :, 0] / 256
def bake(imageFile, assertion_string, newfile=None):
"""
Embeds a serialized representation of a badge instance in a PNG image file.
"""
encoded_assertion_string = codecs.getwriter('utf-8')(assertion_string)
reader = png.Reader(file=imageFile)
if newfile is None:
newfile = NamedTemporaryFile(suffix='.png')
chunkheader = b'openbadges\x00\x00\x00\x00\x00'
chunk_content = chunkheader + encoded_assertion_string.stream.encode('utf-8')
badge_chunk = ('iTXt', chunk_content)
png.write_chunks(newfile, baked_chunks(reader.chunks(), badge_chunk))
newfile.seek(0)
return newfile
def _get_png_info(**kw):
"""\
Returns the width, height and the pixels of the provided PNG file.
"""
reader = PNGReader(**kw)
w, h, pixels, meta = reader.asDirect()
return w, h, _make_pixel_array(pixels, meta['greyscale'])
def validate(self, instance, value):
"""Checks if value is an open PNG file, valid filename, or png.Image
Returns an open bytestream of the image
"""
# Pass if already validated
if getattr(value, '__valid__', False):
return value
# Validate that value is PNG
if isinstance(value, png.Image):
pass
else:
value = super(ImagePNG, self).validate(instance, value)
try:
png.Reader(value).validate_signature()
except png.FormatError:
self.error(instance, value, extra='Open file is not PNG.')
value.seek(0)
# Write input to new bytestream
output = BytesIO()
output.name = self.filename
output.__valid__ = True
if isinstance(value, png.Image):
value.save(output)
else:
fid = value
fid.seek(0)
output.write(fid.read())
fid.close()
output.seek(0)
return output
def file2image(path):
""" Reads an image into a list of lists of pixel values (tuples with
three values). This is a color image. """
(w, h, p, m) = png.Reader(filename = path).asRGBA() # force RGB and alpha
return [_flat2boxed(r) for r in p]
def file2image(path):
""" Reads an image into a list of lists of pixel values (tuples with
three values). This is a color image. """
(w, h, p, m) = png.Reader(filename = path).asRGBA() # force RGB and alpha
return [_flat2boxed(r) for r in p]
def file2image(path):
""" Reads an image into a list of lists of pixel values (tuples with
three values). This is a color image. """
(w, h, p, m) = png.Reader(filename = path).asRGBA() # force RGB and alpha
return [_flat2boxed(r) for r in p]
def file2image(path):
""" Reads an image into a list of lists of pixel values (tuples with
three values). This is a color image. """
(w, h, p, m) = png.Reader(filename = path).asRGBA() # force RGB and alpha
return [_flat2boxed(r) for r in p]
def file2image(path):
""" Reads an image into a list of lists of pixel values (tuples with
three values). This is a color image. """
(w, h, p, m) = png.Reader(filename = path).asRGBA() # force RGB and alpha
return [_flat2boxed(r) for r in p]
def load(self, filename):
'''Carica l'immagine dal file filename'''
with open(filename,'rb') as f:
r = png.Reader(file=f)
iw, ih, png_img, _ = r.asRGB8()
img = []
for png_row in png_img:
row = []
for i in range(0,len(png_row),3):
row.append( Color(png_row[i+0],
png_row[i+1],png_row[i+2]) )
img.append( row )
def main(filename):
width, height, pixels, meta = png.Reader(filename=filename).read()
image_bytes = open(filename, "rb").read()
all_idat_pos = tpng.find_list_in_list(image_bytes, b'IDAT')
if len(all_idat_pos) != 1:
raise Exception(f"IDAT count is {len(all_idat_pos)}")
idat_pos = all_idat_pos[0]
original_idat_len = struct.unpack("!I", image_bytes[idat_pos - 4: idat_pos])[0]
idat_content = image_bytes[idat_pos + 4: idat_pos + 4 + original_idat_len]
uncompressed = zlib.decompress(idat_content)
filter_bytes = [uncompressed[i * (len(uncompressed) // height)] for i in range(0, height)]
result = decode5(filter_bytes)
result_str = ''.join(chr(i) for i in result)
print(f'"{result_str}"')
def write_idat_with_flag(encoded_flag, original_image_file_name, outfile):
reader = png.Reader(filename=original_image_file_name)
width, height, pixels, meta = reader.read()
if height != len(encoded_flag):
raise Exception(f"Encoded flag length {len(encoded_flag)} is not equal to height {height}")
scanlines = list(pixels)
filtered_scanlines = []
for i in range(0, height):
filtered_scanlines.append(
png.filter_scanline(encoded_flag[i], scanlines[i], meta['planes'], scanlines[i - 1] if i > 0 else None))
compressed = zlib.compress(b''.join(filtered_scanlines))
png.write_chunk(outfile, b'IDAT', compressed)
def pngsToRawGlyphBlock(blockSize, pngPath0, pngPath1):
rawData = bytearray(blockSize)
r0 = png.Reader(filename=pngPath0)
r1 = png.Reader(filename=pngPath1)
pngMaps = (r0.read(), r1.read())
if (pngMaps[0][0] != pngMaps[1][0]) or (pngMaps[0][1] != pngMaps[1][1]):
print("Dimensions mismatch between {0} and {1}".format(pngPath0, pngPath1))
exit(1)
if pngMaps[0][3]['bitdepth'] != 2 or pngMaps[1][3]['bitdepth'] != 2:
print("Bitdepth must be 2! (files: {0} {1})".format(pngPath0, pngPath1))
exit(1)
BPP = 2
w = pngMaps[0][0]
h = pngMaps[0][1]
bytesPerLineImg = (2 * w * BPP) // 8
bytesPerLineBlock = blockSize // h
pixels = (list(pngMaps[0][2]), list(pngMaps[1][2]))
for l in range(h):
for nbyte in range(bytesPerLineImg):
npx = nbyte * 2
# lo to hi
px = [
pixels[0][l][npx],
pixels[1][l][npx],
pixels[0][l][npx+1],
pixels[1][l][npx+1]
]
byte = 0
# doing the magic conversion and packing into a byte
for i, p in enumerate(px): byte |= magicPxConvert(p) << 2*i
rawData[l*bytesPerLineBlock+nbyte] = byte
return rawData
def unbake(imageFile):
"""
Return the openbadges content contained in a baked PNG file.
If this doesn't work, return None.
If there is both an iTXt and tEXt chunk with keyword openbadges,
the iTXt chunk content will be returned.
"""
reader = png.Reader(file=imageFile)
for chunktype, content in reader.chunks():
if chunktype == 'iTXt' and content.startswith(b'openbadges\x00'):
return re.sub(b'openbadges[\x00]+', b'', content).decode('utf8')
elif chunktype == 'tEXt' and content.startswith(b'openbadges\x00'):
return content.split('\x00')[1].decode('utf8')
def validate_png(filename):
"""Validate file as a png image. Throws a DCOSException if it is not an PNG
:param filename: path to the image
:type filename: str
:rtype: None
"""
try:
png.Reader(filename=filename).validate_signature()
except Exception as e:
logger.exception(e)
raise DCOSException(
'Unable to validate [{}] as a PNG file'.format(filename))
def load(self, filename):
bmp = []
if self.has_cv:
img = cv2.imread(filename, CV2_READ_ALPHA)
height, width, channels = img.shape
if self.swizzle == SWIZZLE_ROT_90:
img = self._rotate_image(img, -90, width, height)
height_ = height
height = width
width = height_
elif self.swizzle == SWIZZLE_TRANSPOSE:
cv2.flip(img, 0, dst=img)
img = self._rotate_image(img, -90, width, height)
height_ = height
height = width
width = height_
for y in range(height):
for x in range(width):
# OpenCV keeps a BGRA format internally so swap R and B
bgra = list(img[y][x])
b = bgra[0]
bgra[0] = bgra[2]
bgra[2] = b
bmp.append(bgra)
else:
png_file = open(filename, 'rb')
reader = png.Reader(file=png_file)
width, height, pixels, metadata = reader.read()
png_file.close()
for row in list(pixels):
for pixel in range(len(row) / 4):
bmp.append(row[pixel * 4:pixel * 4 + 4])
self.imag = {
'width': width,
'height': height,
'format': FORMAT_RGBA8
}
self.order = '>' if self.big_endian else '<'
self.bmp = self._parse_image_data(bmp, to_bin=True, exact=False)
