Python numpy 模块，byte() 实例源码
我们从Python开源项目中，提取了以下24个代码示例，用于说明如何使用numpy.byte()。
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def test_check_argument_list7():
kernel_name = "test_kernel"
kernel_string = """#define SUM(A, B) (A + B)
// In this file we define test_kernel
__kernel void another_kernel (char number, double factors, int * numbers, const unsigned long * moreNumbers)
__kernel void test_kernel
(double number, double factors, int * numbers, const unsigned long * moreNumbers) {
numbers[get_global_id(0)] = SUM(numbers[get_global_id(0)] * factors[get_global_id(0)], number);
}
// /test_kernel
"""
args = [numpy.byte(5), numpy.float64(4.6), numpy.int32([1, 2, 3]), numpy.uint64([3, 2, 111])]
try:
check_argument_list(kernel_name, kernel_string, args)
print("Expected a TypeError to be raised.")
assert False
except TypeError:
assert True
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def _test_type_repr(self, t):
finfo = np.finfo(t)
last_fraction_bit_idx = finfo.nexp + finfo.nmant
last_exponent_bit_idx = finfo.nexp
storage_bytes = np.dtype(t).itemsize*8
# could add some more types to the list below
for which in ['small denorm', 'small norm']:
# Values from http://en.wikipedia.org/wiki/IEEE_754
constr = np.array([0x00]*storage_bytes, dtype=np.uint8)
if which == 'small denorm':
byte = last_fraction_bit_idx // 8
bytebit = 7-(last_fraction_bit_idx % 8)
constr[byte] = 1 << bytebit
elif which == 'small norm':
byte = last_exponent_bit_idx // 8
bytebit = 7-(last_exponent_bit_idx % 8)
constr[byte] = 1 << bytebit
else:
raise ValueError('hmm')
val = constr.view(t)[0]
val_repr = repr(val)
val2 = t(eval(val_repr))
if not (val2 == 0 and val < 1e-100):
assert_equal(val, val2)
def get_full_alignment_base_quality_scores(read):
"""
Returns base quality scores for the full read alignment, inserting zeroes for deletions and removing
inserted and soft-clipped bases. Therefore, only returns quality for truly aligned sequenced bases.
Args:
read (pysam.AlignedSegment): read to get quality scores for
Returns:
np.array: numpy array of quality scores
"""
quality_scores = np.fromstring(read.qual, dtype=np.byte) - tk_constants.ILLUMINA_QUAL_OFFSET
start_pos = 0
for operation,length in read.cigar:
operation = cr_constants.cigar_numeric_to_category_map[operation]
if operation == 'D':
quality_scores = np.insert(quality_scores, start_pos, [0] * length)
elif operation == 'I' or operation == 'S':
quality_scores = np.delete(quality_scores, np.s_[start_pos:start_pos + length])
if not operation == 'I' and not operation == 'S':
start_pos += length
return start_pos, quality_scores
def get_qvs(qual):
if qual is None:
return None
return numpy.fromstring(qual, dtype=numpy.byte) - ILLUMINA_QUAL_OFFSET
def get_bases_qual(qual, cutoff):
if qual is None:
return None
qvs = numpy.fromstring(qual, dtype=numpy.byte) - ILLUMINA_QUAL_OFFSET
return numpy.count_nonzero(qvs[qvs > cutoff])
def get_min_qual(qual):
if qual is None or len(qual) == 0:
return None
return (numpy.fromstring(qual, dtype=numpy.byte) - ILLUMINA_QUAL_OFFSET).min()
def get_expected_errors(qual):
if qual is None or len(qual) == 0:
return None
qvs = numpy.fromstring(qual, dtype=numpy.byte) - ILLUMINA_QUAL_OFFSET
perr = 10.0**(-qvs/10.0)
return perr.sum()
def read_tile(id, tile, scale=1):
meta = get_metadata(id)
approximate_zoom = meta['meta']['approximateZoom']
bounds = meta['bounds']
height = meta['meta']['height']
width = meta['meta']['width']
zoom_offset = get_zoom_offset(width, height, approximate_zoom)
min_zoom = approximate_zoom - zoom_offset
if not min_zoom <= tile.z <= MAX_ZOOM:
raise InvalidTileRequest('Invalid zoom: {} outside [{}, {}]'.format(tile.z, min_zoom, MAX_ZOOM))
sw = mercantile.tile(*bounds[0:2], zoom=tile.z)
ne = mercantile.tile(*bounds[2:4], zoom=tile.z)
if not sw.x <= tile.x <= ne.x:
raise InvalidTileRequest('Invalid x coordinate: {} outside [{}, {}]'.format(tile.x, sw.x, ne.x))
if not ne.y <= tile.y <= sw.y:
raise InvalidTileRequest('Invalid y coordinate: {} outside [{}, {}]'.format(tile.y, sw.y, ne.y))
data = render_tile(meta, tile, scale=scale)
imgarr = np.ma.transpose(data, [1, 2, 0]).astype(np.byte)
out = StringIO()
im = Image.fromarray(imgarr, 'RGBA')
im.save(out, 'png')
return out.getvalue()
def __init__(self, candidate, index, length, decoder, parent=None):
self.decoder = decoder #the decoder provides the necessary context, it is in turn tied to the corrector
self.parent = parent #links to the parent hypothesis that generated this one
self.candidate = candidate #or None for the initial root hypothesis
self.index = index #the position of the last added candidate in the original testtokens sequence
self.length = length #the length of the last added candidate
#if parent is None:
# self.covered = np.zeros(len(self.decoder), dtype=np.byte)
#else:
# self.covered = self.parent.covered.copy()
# self.covered[self.index:self.index+self.length+1] = 1
self.logprob = self.computeprob()
if self.decoder.corrector.args.debug:
print("[DEBUG] Generated Hypothesis " + repr(self), file=sys.stderr)
def __next__(self):
tmp = self.fdata.read(self.nrows*self.ncols)
if tmp == "": raise StopIteration
#image = np.array(struct.unpack("{0}B", tmp), dtype=np.byte). \
# reshape((self.nrows, self.ncols))
# notice we shall normalize the input
image = np.array(struct.unpack("{0}B".format(self.nrows*self.ncols), tmp), dtype=np.float32) / 256.0
#print np.max(image), np.min(image)
return image
def test_check_argument_list2():
kernel_name = "test_kernel"
kernel_string = """__kernel void test_kernel
(char number, double factors, int * numbers, const unsigned long * moreNumbers) {
numbers[get_global_id(0)] = numbers[get_global_id(0)] * factors[get_global_id(0)] + number;
}
"""
args = [numpy.byte(5), numpy.float64(4.6), numpy.int32([1, 2, 3]), numpy.uint64([3, 2, 111])]
check_argument_list(kernel_name, kernel_string, args)
#test that no exception is raised
assert True
def test_check_argument_list6():
kernel_name = "test_kernel"
kernel_string = """// This is where we define test_kernel
#define SUM(A, B) (A + B)
__kernel void test_kernel
(char number, double factors, int * numbers, const unsigned long * moreNumbers) {
numbers[get_global_id(0)] = SUM(numbers[get_global_id(0)] * factors[get_global_id(0)], number);
}
// /test_kernel
"""
args = [numpy.byte(5), numpy.float64(4.6), numpy.int32([1, 2, 3]), numpy.uint64([3, 2, 111])]
check_argument_list(kernel_name, kernel_string, args)
#test that no exception is raised
assert True
def __init__(self, packet_cb=None, skipped_cb=None, cksum_err_cb=None):
gr.sync_block.__init__(self, "indri_smartnet_deframer",
in_sig=[numpy.byte],
out_sig=None)
self.set_history(self.FRAME_LEN)
self.nsamples = 0
self.packet_cb = packet_cb
self.skipped_cb = skipped_cb
self.cksum_err_cb = cksum_err_cb
self.counts = { "good": 0, "bad": 0, "nsamples": 0 }
def correct_bc_error(bc_confidence_threshold, seq, qual, wl_dist):
'''Attempt to correct an incorrect BC sequence by computing
the probability that a Hamming distance=1 BC generated
the observed sequence, accounting for the prior distribution
of the whitelist barcodes (wl_dist), and the QV of the base
that must have been incorrect'''
# QV values
qvs = np.fromstring(qual, dtype=np.byte) - tk_constants.ILLUMINA_QUAL_OFFSET
# Char array of read
a = array.array('c', seq)
# Likelihood of candidates
wl_cand = []
likelihoods = []
# Enumerate Hamming distance 1 sequences - if a sequence
# is on the whitelist, compute it's likelihood.
for pos in range(len(a)):
existing = a[pos]
for c in tk_seq.NUCS:
if c == existing:
continue
a[pos] = c
test_str = a.tostring()
# prior probability of this BC
p_bc = wl_dist.get(test_str)
if p_bc is not None:
# probability of the base error
edit_qv = min(33.0, float(qvs[pos]))
p_edit = 10.0**(-edit_qv/10.0)
wl_cand.append(test_str)
likelihoods.append(p_bc * p_edit)
a[pos] = existing
posterior = np.array(likelihoods)
posterior /= posterior.sum()
if len(posterior) > 0:
pmax = posterior.max()
if pmax > bc_confidence_threshold:
return wl_cand[np.argmax(posterior)]
return None
def run(self):
self._stop.clear()
with self._conf_lock:
conf = self._conf.copy() # Create thread-safe local copy
sleep(float(conf["capture-warmup"])) # Camera warm-up wait
while True :
if self._stop.is_set():
break
if self._new_conf.is_set():
with self._conf_lock:
conf = self._conf.copy()
self._new_conf.clear()
logging.debug("New configuration set: {conf}".format(conf=conf))
if conf["capture"]:
if self._stream is None:
if self.tryOpenStream() is FAIL:
continue
try:
select.select((self._stream,), (), ())
raw = self._stream.read_and_queue()
except IOError as err_first:
self._stream.close()
self.tryOpenStream()
continue
if raw is None:
logging.warning("Grabbed frame is empty.")
while True:
try:
self._out_queue.put(cv2.imdecode(np.fromstring(raw, dtype=np.byte), flags=cv2.IMREAD_COLOR), block=False)
except Full:
self._out_queue.get()
else:
break
else:
sleep(1) # Reduce CPU consumption
if self._stream is not None:
self._stream.close()
logging.info("Thread stopped.")
def __init__(self, filename_or_obj, dataset, preamble=None, file_meta=None,
is_implicit_VR=True, is_little_endian=True):
"""Initialize a dataset read from a DICOM file.
Parameters
----------
filename_or_obj : str, None
Full path and filename to the file. Use None if is a BytesIO.
dataset : Dataset, dict
Some form of dictionary, usually a Dataset from read_dataset()
preamble : None, optional
The 128-byte DICOM preamble
file_meta : None, optional
The file meta info dataset, as returned by _read_file_meta,
or an empty dataset if no file meta information is in the file.
is_implicit_VR : boolean, optional
True (default) if implicit VR transfer syntax used; False if explicit VR.
is_little_endian : boolean
True (default) if little-endian transfer syntax used; False if big-endian.
"""
Dataset.__init__(self, dataset)
self.preamble = preamble
self.file_meta = file_meta
self.is_implicit_VR = is_implicit_VR
self.is_little_endian = is_little_endian
if isinstance(filename_or_obj, compat.string_types):
self.filename = filename_or_obj
self.fileobj_type = open
elif isinstance(filename_or_obj, io.BufferedReader):
self.filename = filename_or_obj.name
# This is the appropriate constructor for io.BufferedReader
self.fileobj_type = open
else:
self.fileobj_type = filename_or_obj.__class__ # use __class__ python <2.7?; http://docs.python.org/reference/datamodel.html
if getattr(filename_or_obj, "name", False):
self.filename = filename_or_obj.name
elif getattr(filename_or_obj, "filename", False): # gzip python <2.7?
self.filename = filename_or_obj.filename
else:
self.filename = None # e.g. came from BytesIO or something file-like
self.timestamp = None
if stat_available and self.filename and os.path.exists(self.filename):
statinfo = os.stat(self.filename)
self.timestamp = statinfo.st_mtime
def get_test_content(self, filename, filename_info, filetype_info):
"""Mimic reader input file content"""
file_content = {
'/attr/Platform_Name': filename_info['platform_shortname'],
'/attr/Element_Resolution': 2.,
'/attr/Line_Resolution': 2.,
'/attr/Subsatellite_Longitude': -70.2 if 'GOES' in filename_info['platform_shortname'] else 140.65,
'pixel_longitude': DEFAULT_LON_DATA,
'pixel_longitude/attr/scale_factor': 1.,
'pixel_longitude/attr/add_offset': 0.,
'pixel_longitude/shape': DEFAULT_FILE_SHAPE,
'pixel_longitude/attr/_FillValue': np.nan,
'pixel_latitude': DEFAULT_LAT_DATA,
'pixel_latitude/attr/scale_factor': 1.,
'pixel_latitude/attr/add_offset': 0.,
'pixel_latitude/shape': DEFAULT_FILE_SHAPE,
'pixel_latitude/attr/_FillValue': np.nan,
}
sensor = {
'HIMAWARI-8': 'himawari8',
'GOES-16': 'goes16',
'GOES-13': 'goes',
'GOES-14': 'goes',
'GOES-15': 'goes',
}[filename_info['platform_shortname']]
file_content['/attr/Sensor_Name'] = sensor
if filename_info['platform_shortname'] == 'HIMAWARI-8':
file_content['pixel_longitude'] = DEFAULT_LON_DATA + 130.
file_content['variable1'] = DEFAULT_FILE_DATA.astype(np.float32)
file_content['variable1/attr/_FillValue'] = -1
file_content['variable1/attr/scale_factor'] = 1.
file_content['variable1/attr/add_offset'] = 0.
file_content['variable1/attr/units'] = '1'
file_content['variable1/shape'] = DEFAULT_FILE_SHAPE
# data with fill values
file_content['variable2'] = np.ma.masked_array(
DEFAULT_FILE_DATA.astype(np.float32),
mask=np.zeros_like(DEFAULT_FILE_DATA))
file_content['variable2'].mask[::5, ::5] = True
file_content['variable2/attr/_FillValue'] = -1
file_content['variable2/attr/scale_factor'] = 1.
file_content['variable2/attr/add_offset'] = 0.
file_content['variable2/attr/units'] = '1'
file_content['variable2/shape'] = DEFAULT_FILE_SHAPE
# category
file_content['variable3'] = DEFAULT_FILE_DATA.astype(np.byte)
file_content['variable3/attr/_FillValue'] = -128
file_content['variable3/attr/flag_meanings'] = "clear water supercooled mixed ice unknown"
file_content['variable3/attr/flag_values'] = [0, 1, 2, 3, 4, 5]
file_content['variable3/attr/units'] = '1'
file_content['variable3/shape'] = DEFAULT_FILE_SHAPE
return file_content
def __init__(self, filename_or_obj, dataset, preamble=None, file_meta=None,
is_implicit_VR=True, is_little_endian=True):
"""Initialize a dataset read from a DICOM file.
Parameters
----------
filename_or_obj : str, None
Full path and filename to the file. Use None if is a BytesIO.
dataset : Dataset, dict
Some form of dictionary, usually a Dataset from read_dataset()
preamble : None, optional
The 128-byte DICOM preamble
file_meta : None, optional
The file meta info dataset, as returned by _read_file_meta,
or an empty dataset if no file meta information is in the file.
is_implicit_VR : boolean, optional
True (default) if implicit VR transfer syntax used; False if explicit VR.
is_little_endian : boolean
True (default) if little-endian transfer syntax used; False if big-endian.
"""
Dataset.__init__(self, dataset)
self.preamble = preamble
self.file_meta = file_meta
self.is_implicit_VR = is_implicit_VR
self.is_little_endian = is_little_endian
if isinstance(filename_or_obj, compat.string_types):
self.filename = filename_or_obj
self.fileobj_type = open
elif isinstance(filename_or_obj, io.BufferedReader):
self.filename = filename_or_obj.name
# This is the appropriate constructor for io.BufferedReader
self.fileobj_type = open
else:
self.fileobj_type = filename_or_obj.__class__ # use __class__ python <2.7?; http://docs.python.org/reference/datamodel.html
if getattr(filename_or_obj, "name", False):
self.filename = filename_or_obj.name
elif getattr(filename_or_obj, "filename", False): # gzip python <2.7?
self.filename = filename_or_obj.filename
else:
self.filename = None # e.g. came from BytesIO or something file-like
self.timestamp = None
if stat_available and self.filename and os.path.exists(self.filename):
statinfo = os.stat(self.filename)
self.timestamp = statinfo.st_mtime