def to_libpressio(x):
op = None
if isinstance(value, np.ndarray):
value_lp = pressio.io_data_from_numpy(value)
op = pressio.option_new_data(value_lp)
pressio.data_free(value_lp)
elif isinstance(value, list):
if value:
# list is non-empty
if isinstance(value[0], str):
op = pressio.option_new_strings(
pressio.vector_string([i.encode() for i in value]))
elif isinstance(value[0], int) or isinstance(value[0], float):
arr = np.array(value)
lp = pressio.io_data_from_numpy(arr)
op = pressio.option_new_data(lp)
pressio.data_free(lp)
else:
raise TypeError("unexpected list type: " + value)
else:
# list is empty
op = pressio.option_new_strings(pressio.vector_string())
elif isinstance(value, float):
op = pressio.option_new_double(value)
elif isinstance(value, str):
op = pressio.option_new_string(value.encode())
elif isinstance(value, bytes):
op = pressio.option_new_string(value)
elif isinstance(value, int):
op = pressio.option_new_integer64(value)
else:
raise TypeError("Unsupported type " + str(type(value)))
return op
def decode(self, compressed, decompressed=None):
"""perform decompression
params:
compressed: bytes - the data to be decompressed
decompressed: numpy.ndarray - memory to be used to decompress data into
"""
compressed_lp = None
decompressed_lp = None
try:
compressed_lp = pressio.io_data_from_bytes(compressed)
decompressed_lp = pressio.io_data_from_numpy(decompressed)
rc = pressio.compressor_decompress(self._compressor, compressed_lp,
decompressed_lp)
if rc:
raise PressioException.from_compressor(self._compressor)
dec = pressio.io_data_to_numpy(decompressed_lp)
if decompressed is not None:
return dec
else:
return ndarray_copy(dec, decompressed)
finally:
pressio.data_free(compressed_lp)
pressio.data_free(decompressed_lp)
def evaluate(self, input=None, compressed=None, output=None):
results_lp = None
try:
input_lp = input if input is None else pressio.io_data_from_numpy(
input)
compressed_lp = compressed if compressed is None else pressio.io_data_from_bytes(
compressed)
output_lp = output if output is None else pressio.io_data_from_numpy(
output)
results_lp = pressio.metrics_evaluate(self._metric, input_lp,
compressed_lp, output_lp)
return _pressio_to_python(results_lp)
finally:
if input_lp is not None:
pressio.data_free(input_lp)
if output_lp is not None:
pressio.data_free(output_lp)
if compressed_lp is not None:
pressio.data_free(compressed_lp)
if results_lp is not None:
pressio.options_free(results_lp)
def convert_back_and_forth(nd_array):
try:
p_data = pressio.io_data_from_numpy(nd_array)
n_data = pressio.io_data_to_numpy(p_data)
pressio.data_free(p_data)
assert np.array_equal(nd_array, n_data), f"FAILED nd_array size={nd_array.shape}, dtype={nd_array.dtype}"
except (AssertionError,TypeError) as e:
print(e)
global FAILED
FAILED += 1
else:
global PASSED
PASSED += 1
def write(self, output):
"""reads a data buffer to a file
params:
output: np.ndarray - the file to be written
"""
try:
out = pressio.io_data_from_numpy(output)
ret = pressio.io_write(self._io, out)
if ret:
raise PressioException.from_io(self._io)
return ret
finally:
pressio.data_free(out)
def read(self, template=None):
"""reads a data buffer from a file
params:
template: Optional[np.ndarray] - a input template if one is provided
"""
if template is not None:
template = pressio.io_data_from_numpy(template)
ret_lp = pressio.io_read(self._io, template)
if not ret_lp:
raise PressioException.from_io(self._io)
ret = pressio.io_data_to_numpy(ret_lp)
pressio.data_free(ret_lp)
return ret
def encode(self, uncompressed):
"""perform compression
params:
uncompressed: np.ndarray - the data to be compressed
"""
uncompressed_lp = None
compressed_lp = None
try:
uncompressed_lp = pressio.io_data_from_numpy(uncompressed)
compressed_lp = pressio.data_new_empty(pressio.byte_dtype,
pressio.vector_uint64_t())
rc = pressio.compressor_compress(self._compressor, uncompressed_lp,
compressed_lp)
if rc:
raise PressioException.from_compressor(self._compressor)
comp = pressio.io_data_to_bytes(compressed_lp)
finally:
pressio.data_free(uncompressed_lp)
pressio.data_free(compressed_lp)
return comp
library = pressio.instance()
compressor = pressio.get_compressor(library, b"sz")
sz_options = pressio.compressor_get_options(compressor)
metric_ids = pressio.vector_string([b'time', b'size'])
metrics = pressio.new_metrics(library, metric_ids)
pressio.options_set_integer(sz_options, b"sz:error_bound_mode", sz.PSNR)
pressio.options_set_double(sz_options, b"sz:psnr_err_bound",
float(sys.argv[1]))
pressio.compressor_check_options(compressor, sz_options)
pressio.compressor_set_options(compressor, sz_options)
pressio.compressor_set_metrics(compressor, metrics)
input_data = pressio.io_data_from_numpy(floatArray)
compressed_data = pressio.data_new_empty(pressio.byte_dtype,
pressio.vector_uint64_t())
dims = pressio.vector_uint64_t([height, width, 3])
decompressed_data = pressio.data_new_empty(pressio.double_dtype, dims)
#compress data with selected compressor
pressio.compressor_compress(compressor, input_data, compressed_data)
#decompress data with selected compressor
pressio.compressor_decompress(compressor, compressed_data,
decompressed_data)
#get metric results for compression
metric_results = pressio.compressor_get_metrics_results(compressor)
library = pressio.instance()
compressor = pressio.get_compressor(library, b"sz")
sz_options = pressio.compressor_get_options(compressor)
metrics_ids = pressio.vector_string([b'time', b'size'])
metrics = pressio.new_metrics(library, metrics_ids)
pressio.options_set_integer(sz_options, b"sz:error_bound_mode", sz.ABS)
pressio.options_set_double(sz_options, b"sz:abs_err_bound", 0.5)
pressio.compressor_check_options(compressor, sz_options)
pressio.compressor_set_options(compressor, sz_options)
pressio.compressor_set_metrics(compressor, metrics)
data = np.random.rand(300, 300, 300)
input_data = pressio.io_data_from_numpy(data)
compressed_data = pressio.data_new_empty(pressio.byte_dtype,
pressio.vector_uint64_t())
dims = pressio.vector_uint64_t([300, 300, 300])
decompressed_data = pressio.data_new_empty(pressio.double_dtype, dims)
pressio.compressor_compress(compressor, input_data, compressed_data)
pressio.compressor_decompress(compressor, compressed_data, decompressed_data)
metric_results = pressio.compressor_get_metrics_results(compressor)
compression_ratio = pressio.new_double()
pressio.options_get_double(metric_results, b"size:compression_ratio",
compression_ratio)