def update(self):
self._display_init()
x1, x2 = self.update_x1, self.update_x2
y1, y2 = self.update_y1, self.update_y2
region = self.buffer[y1:y2, x1:x2]
if self.v_flip:
region = numpy.fliplr(region)
if self.h_flip:
region = numpy.flipud(region)
buf_red = numpy.packbits(numpy.where(region == RED, 1, 0)).tolist()
if self.inky_version == 1:
buf_black = numpy.packbits(numpy.where(region == 0, 0, 1)).tolist()
else:
buf_black = numpy.packbits(numpy.where(region == BLACK, 0, 1)).tolist()
self._display_update(buf_black, buf_red)
self._display_fini()
python类packbits()的实例源码
def hsh_to_patches(self, hsh):
pp = extract_patches_2d(hsh.astype(int), (self.patch_size, self.patch_size))
# flatten 2nd and 3rd dimension:
pp = pp.reshape((pp.shape[0], -1))
# extract sample of patches:
max_patches = min(self.max_patches, pp.shape[0])
rr = [pp[x] for x in np.linspace(0, pp.shape[0], max_patches, endpoint=False).astype(int)]
# pack patches into numbers:
packed = [int(binascii.b2a_hex(''.join(np.packbits(x).view('c'))) or '0', 16) for x in rr]
return packed
def test_packbits_empty_with_axis():
# Original shapes and lists of packed shapes for different axes.
shapes = [
((0,), [(0,)]),
((10, 20, 0), [(2, 20, 0), (10, 3, 0), (10, 20, 0)]),
((10, 0, 20), [(2, 0, 20), (10, 0, 20), (10, 0, 3)]),
((0, 10, 20), [(0, 10, 20), (0, 2, 20), (0, 10, 3)]),
((20, 0, 0), [(3, 0, 0), (20, 0, 0), (20, 0, 0)]),
((0, 20, 0), [(0, 20, 0), (0, 3, 0), (0, 20, 0)]),
((0, 0, 20), [(0, 0, 20), (0, 0, 20), (0, 0, 3)]),
((0, 0, 0), [(0, 0, 0), (0, 0, 0), (0, 0, 0)]),
]
for dt in '?bBhHiIlLqQ':
for in_shape, out_shapes in shapes:
for ax, out_shape in enumerate(out_shapes):
a = np.empty(in_shape, dtype=dt)
b = np.packbits(a, axis=ax)
assert_equal(b.dtype, np.uint8)
assert_equal(b.shape, out_shape)
def test_packbits():
# Copied from the docstring.
a = [[[1, 0, 1], [0, 1, 0]],
[[1, 1, 0], [0, 0, 1]]]
for dtype in [np.bool, np.uint8, np.int]:
arr = np.array(a, dtype=dtype)
b = np.packbits(arr, axis=-1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
def decompress_rle(data, # type: bytes
shape, # type: Tuple[int, int]
depth, # type: int
version # type: int
): # type: (...) -> np.ndarray
"""
Decompress run length encoded data.
{}
"""
output = packbits.decode(
data, shape[0], shape[1], color_depth_size_map[depth], version)
# Now pass along to the raw decoder to get a Numpy array
return decompress_raw(output, shape, depth, version)
def decompress_zip_prediction(data, # type: bytes
shape, # type: Tuple[int, int]
depth, # type: int
version # type: int
): # type: (...) -> np.ndarray
"""
Decompress zip (zlib) with prediction encoded data.
Not supported for 1- or 32-bit images.
{}
"""
if depth == 1: # pragma: no cover
raise ValueError(
"zip with prediction is not supported for 1-bit images")
elif depth == 32:
raise ValueError(
"zip with prediction is not implemented for 32-bit images")
elif depth == 8:
decoder = packbits.decode_prediction_8bit
else:
decoder = packbits.decode_prediction_16bit
data = zlib.decompress(data)
image = util.ensure_native_endian(
decompress_raw(data, shape, depth, version))
for i in range(len(image)):
decoder(image[i].flatten())
return image
def normalize_image(image, # type: np.ndarray
depth # type: int
): # type: (...) -> np.ndarray
if depth == 1:
image = np.packbits(image.flatten())
return image
def compress_rle(fd, # type: BinaryIO
image, # type: np.ndarray
depth, # type: int
version # type: int
): # type: (...) -> None
"""
Write a Numpy array to a run length encoded stream.
{}
"""
if depth == 1: # pragma: no cover
raise ValueError(
"rle compression is not supported for 1-bit images")
start = fd.tell()
if version == 1:
fd.seek(image.shape[0] * 2, 1)
lengths = np.empty((len(image),), dtype='>u2')
else:
fd.seek(image.shape[0] * 4, 1)
lengths = np.empty((len(image),), dtype='>u4')
if util.needs_byteswap(image):
for i, row in enumerate(image):
row = util.do_byteswap(row)
packed = packbits.encode(row)
lengths[i] = len(packed)
fd.write(packed)
else:
for i, row in enumerate(image):
packed = packbits.encode(row)
lengths[i] = len(packed)
fd.write(packed)
end = fd.tell()
fd.seek(start)
fd.write(lengths.tobytes())
fd.seek(end)
def compress_zip_prediction(fd, # type: BinaryIO
image, # type: np.ndarray
depth, # type: int
version # type: int
): # type: (...) -> None
"""
Write a Numpy array to a zip (zlib) with prediction compressed
stream.
Not supported for 1- or 32-bit images.
{}
"""
if depth == 1: # pragma: no cover
raise ValueError(
"zip with prediction is not supported for 1-bit images")
elif depth == 32: # pragma: no cover
raise ValueError(
"zip with prediction is not implemented for 32-bit images")
elif depth == 8:
encoder = packbits.encode_prediction_8bit
elif depth == 16:
encoder = packbits.encode_prediction_16bit
compressor = zlib.compressobj()
for row in image:
encoder(row.flatten())
row = util.ensure_bigendian(row)
fd.write(compressor.compress(row))
fd.write(compressor.flush())
def compress_constant_zip_prediction(fd, # type: BinaryIO
value, # type: int
width, # type: int
rows, # type: int
depth, # type: int
version # type: int
): # type: (...) -> np.ndarray
"""
Write a virtual image containing a constant to a zip with
prediction compressed stream.
{}
"""
if depth == 1: # pragma: no cover
raise ValueError(
"zip with prediction is not supported for 1-bit images")
elif depth == 32: # pragma: no cover
raise ValueError(
"zip with prediction is not implemented for 32-bit images")
elif depth == 8:
encoder = packbits.encode_prediction_8bit
elif depth == 16:
encoder = packbits.encode_prediction_16bit
row = _make_constant_row(value, width, depth)
row = row.reshape((1, width))
row = util.ensure_native_endian(row)
encoder(row.flatten())
row = util.ensure_bigendian(row)
row = row.tobytes()
fd.write(zlib.compress(row * rows))
def write(self, filename):
header_bytes = struct.pack(CHUNK_HEADER_FORMAT, self.data_size, self.board_size, self.input_planes, self.is_test)
position_bytes = np.packbits(self.pos_features).tostring()
next_move_bytes = np.packbits(self.next_moves).tostring()
with gzip.open(filename, "wb", compresslevel=6) as f:
f.write(header_bytes)
f.write(position_bytes)
f.write(next_move_bytes)
def frame_1090es_ppm_modulate(even, odd):
ppm = [ ]
for i in range(48): # pause
ppm.append( 0 )
ppm.append( 0xA1 ) # preamble
ppm.append( 0x40 )
for i in range(len(even)):
word16 = numpy.packbits(manchester_encode(~even[i]))
ppm.append(word16[0])
ppm.append(word16[1])
for i in range(100): # pause
ppm.append( 0 )
ppm.append( 0xA1 ) # preamble
ppm.append( 0x40 )
for i in range(len(odd)):
word16 = numpy.packbits(manchester_encode(~odd[i]))
ppm.append(word16[0])
ppm.append(word16[1])
for i in range(48): # pause
ppm.append( 0 )
#print '[{}]'.format(', '.join(hex(x) for x in ppm))
return bytearray(ppm)
def pack(a):
"""Pack a boolean array *a* so that it takes 8x less space."""
return np.packbits(a.view(np.uint8))
def test_packbits():
# Copied from the docstring.
a = [[[1, 0, 1], [0, 1, 0]],
[[1, 1, 0], [0, 0, 1]]]
for dtype in [np.bool, np.uint8, np.int]:
arr = np.array(a, dtype=dtype)
b = np.packbits(arr, axis=-1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
def boolMasksToImage(masks):
'''
Transform at maximum 8 bool layers --> 2d arrays, dtype=(bool,int)
to one 8bit image
'''
assert len(masks) <= 8, 'can only transform up to 8 masks into image'
masks = np.asarray(masks, dtype=np.uint8)
assert masks.ndim == 3, 'layers need to be stack of 2d arrays'
return np.packbits(masks, axis=0)[0].T
def img_to_terms(self, img_data_uri = False, img_bytes = False):
if img_data_uri:
if type(img_data_uri) is unicode:
img_data_uri = img_data_uri.encode('utf8')
img = Image.open(StringIO(decode_image(img_data_uri)))
else:
assert img_bytes is not False
img = Image.open(StringIO(img_bytes))
hsh = binascii.b2a_hex(np.packbits(self.hash_func(img, hash_size = self.hash_size).hash).tobytes())
return {'dedupe_hsh': hsh}
def lsb_decode(image):
try:
red, green, blue = image.split()
watermark = ImageMath.eval("(a&0x1)*0x01", a=red)
watermark = watermark.convert('L')
watermark_bytes = bytes(watermark.getdata())
watermark_bits_array = np.fromiter(watermark_bytes, dtype=np.uint8)
watermark_bytes_array = np.packbits(watermark_bits_array)
watermark_bytes = bytes(watermark_bytes_array)
bytes_io = BytesIO(watermark_bytes)
return load(bytes_io)
except UnpicklingError:
return ''
def test_packbits():
# Copied from the docstring.
a = [[[1, 0, 1], [0, 1, 0]],
[[1, 1, 0], [0, 0, 1]]]
for dtype in [np.bool, np.uint8, np.int]:
arr = np.array(a, dtype=dtype)
b = np.packbits(arr, axis=-1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
def test_packbits():
# Copied from the docstring.
a = [[[1, 0, 1], [0, 1, 0]],
[[1, 1, 0], [0, 0, 1]]]
for dtype in [np.bool, np.uint8, np.int]:
arr = np.array(a, dtype=dtype)
b = np.packbits(arr, axis=-1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
def addition_problem(ReccurentLayer):
X_train, X_test, y_train, y_test = addition_dataset(8, 5000)
print(X_train.shape, X_test.shape)
model = NeuralNet(
layers=[
ReccurentLayer,
TimeDistributedDense(1),
Activation('sigmoid'),
],
loss='mse',
optimizer=Adam(),
metric='mse',
batch_size=64,
max_epochs=15,
)
model.fit(X_train, y_train)
predictions = np.round(model.predict(X_test))
predictions = np.packbits(predictions.astype(np.uint8))
y_test = np.packbits(y_test.astype(np.int))
print(accuracy(y_test, predictions))
# RNN
# addition_problem(RNN(16, parameters=Parameters(constraints={'W': SmallNorm(), 'U': SmallNorm()})))
# LSTM
def read_all_games(fn_in, fn_out):
g = h5py.File(fn_out, 'w')
X = g.create_dataset('x', (0, 28 * 8), dtype='b', maxshape=(None, 28 * 8), chunks=True) # dtype='b'
M = g.create_dataset('m', (0, 1), dtype='float32', maxshape=(None, 1), chunks=True)
size = 0
line = 0
for game in read_games(fn_in):
game = parse_game(game)
if game is None:
continue
for x, m in game :
if line + 1 >= size:
g.flush()
size = 2 * size + 1
print 'resizing to', size
[d.resize(size=size, axis=0) for d in (X, M)]
X[line] = numpy.packbits(x)
M[line] = m
line += 1
print 'shrink to', line
[d.resize(size=line, axis=0) for d in (X, M)] # shrink to fit
g.close()
def isNear(self, address):
difference = 0
# a logically anded array ([true, false, ..]) multiplied by an integer is promoted to an int array.
# Which then can be sent to packbits, that here returns an array of 1 element, so now z is an integer
z = np.packbits(np.logical_and(self.address, address)*1)[0]
while z:
difference += 1
z &= z-1 # magic!
return 1 if difference < self.radius else 0
def test_packbits():
# Copied from the docstring.
a = [[[1, 0, 1], [0, 1, 0]],
[[1, 1, 0], [0, 0, 1]]]
for dt in '?bBhHiIlLqQ':
arr = np.array(a, dtype=dt)
b = np.packbits(arr, axis=-1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
def test_packbits_empty():
shapes = [
(0,), (10, 20, 0), (10, 0, 20), (0, 10, 20), (20, 0, 0), (0, 20, 0),
(0, 0, 20), (0, 0, 0),
]
for dt in '?bBhHiIlLqQ':
for shape in shapes:
a = np.empty(shape, dtype=dt)
b = np.packbits(a)
assert_equal(b.dtype, np.uint8)
assert_equal(b.shape, (0,))
def prepare_packed(data, output_fname):
print("prepare packed:")
with tictoc():
with tf.python_io.TFRecordWriter(output_fname) as writer:
for atom_features in data:
value = np.packbits(atom_features.reshape(-1)).tobytes()
bit_features = tf.train.Feature(bytes_list = tf.train.BytesList(value=value))
features = {'bit_features' : bit_features}
example = tf.train.Example(features=tf.train.Features(feature=features))
serialized_example = example.SerializeToString()
writer.write(serialized_example)
print("File size: {} bytes".format(os.path.getsize(output_fname)))
def pack_state(self, state):
black = np.packbits(state == Board.STONE_BLACK)
white = np.packbits(state == Board.STONE_WHITE)
empty = np.packbits(state == Board.STONE_EMPTY)
image = np.concatenate((black, white, empty))
return bytes(image)
def _tofile(self, fh, pam=False):
"""Write Netbm file."""
fh.seek(0)
fh.write(self._header(pam))
data = self.asarray(copy=False)
if self.maxval == 1:
data = numpy.packbits(data, axis=-1)
data.tofile(fh)
def crossbar_rows(self):
"""Returns a list of crossbar rows"""
rows = []
for i in range(self.num_neurons):
rows.append({
'type': 'S%d' % self.axon_type[i],
'synapses': (' '.join(map(lambda x: format(x, '02x'), np.packbits(self.w[i, :])))).upper()
})
return rows
def _to_hash(projected):
if projected.shape[1] % 8 != 0:
raise ValueError('Require reduced dimensionality to be a multiple '
'of 8 for hashing')
# XXX: perhaps non-copying operation better
out = np.packbits((projected > 0).astype(int)).view(dtype=HASH_DTYPE)
return out.reshape(projected.shape[0], -1)
def _generate_masks(self):
"""Creates left and right masks for all hash lengths."""
tri_size = MAX_HASH_SIZE + 1
# Called once on fitting, output is independent of hashes
left_mask = np.tril(np.ones((tri_size, tri_size), dtype=int))[:, 1:]
right_mask = left_mask[::-1, ::-1]
self._left_mask = np.packbits(left_mask).view(dtype=HASH_DTYPE)
self._right_mask = np.packbits(right_mask).view(dtype=HASH_DTYPE)
