我们从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_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 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
