The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def kernel(self, X, Y=None):
"""
Computes the hypercube kerpy k(x,y)=tanh(gamma)^d(x,y), where d is the
Hamming distance between x and y
X - 2d numpy.bool8 array, samples on right left side
Y - 2d numpy.bool8 array, samples on left hand side.
Can be None in which case its replaced by X
"""
if not type(X) is numpy.ndarray:
raise TypeError("X must be numpy array")
if not len(X.shape) == 2:
raise ValueError("X must be 2D numpy array")
if not X.dtype == numpy.bool8:
raise ValueError("X must be boolean numpy array")
if not Y is None:
if not type(Y) is numpy.ndarray:
raise TypeError("Y must be None or numpy array")
if not len(Y.shape) == 2:
raise ValueError("Y must be None or 2D numpy array")
if not Y.dtype == numpy.bool8:
raise ValueError("Y must be boolean numpy array")
if not X.shape[1] == Y.shape[1]:
raise ValueError("X and Y must have same dimension if Y is not None")
# un-normalise normalised hamming distance in both cases
if Y is None:
K = tanh(self.gamma) ** squareform(pdist(X, 'hamming') * X.shape[1])
else:
K = tanh(self.gamma) ** (cdist(X, Y, 'hamming') * X.shape[1])
return K Example 2
def test_bool_types(self):
_skip_if_no_xlrd()
for np_type in (np.bool8, np.bool_):
with ensure_clean(self.ext) as path:
# Test np.bool values read come back as float.
frame = (DataFrame([1, 0, True, False], dtype=np_type))
frame.to_excel(path, 'test1')
reader = ExcelFile(path)
recons = read_excel(reader, 'test1').astype(np_type)
tm.assert_frame_equal(frame, recons) Example 3
def __read_segment_list_v9(self):
"""
Read a list of Segments with comments.
This is version 9 of the data sequence.
This is the same as __read_segment_list_v8, but contains some
additional annotations. These annotations are added to the Segment.
--------------------------------------------------------
Returns a list of the Segments created with this method.
The returned objects are already added to the Block.
ID: 29120
"""
# segment_collection_v8 -- this is based off a segment_collection_v8
segments = self.__read_segment_list_v8()
# uint8
feature_type = np.fromfile(self._fsrc, dtype=np.uint8,
count=1)[0]
# uint8
go_by_closest_unit_center = np.fromfile(self._fsrc, dtype=np.bool8,
count=1)[0]
# uint8
include_unit_bounds = np.fromfile(self._fsrc, dtype=np.bool8,
count=1)[0]
# create a dictionary of the annotations
annotations = {'feature_type': feature_type,
'go_by_closest_unit_center': go_by_closest_unit_center,
'include_unit_bounds': include_unit_bounds}
# add the annotations to each Segment
for segment in segments:
segment.annotations.update(annotations)
return segments Example 4
def __read_segment_list_v9(self):
"""
Read a list of Segments with comments.
This is version 9 of the data sequence.
This is the same as __read_segment_list_v8, but contains some
additional annotations. These annotations are added to the Segment.
--------------------------------------------------------
Returns a list of the Segments created with this method.
The returned objects are already added to the Block.
ID: 29120
"""
# segment_collection_v8 -- this is based off a segment_collection_v8
segments = self.__read_segment_list_v8()
# uint8
feature_type = np.fromfile(self._fsrc, dtype=np.uint8,
count=1)[0]
# uint8
go_by_closest_unit_center = np.fromfile(self._fsrc, dtype=np.bool8,
count=1)[0]
# uint8
include_unit_bounds = np.fromfile(self._fsrc, dtype=np.bool8,
count=1)[0]
# create a dictionary of the annotations
annotations = {'feature_type': feature_type,
'go_by_closest_unit_center': go_by_closest_unit_center,
'include_unit_bounds': include_unit_bounds}
# add the annotations to each Segment
for segment in segments:
segment.annotations.update(annotations)
return segments Example 5
def omit_hsp_points(self, distance=0, reset=False):
"""Exclude head shape points that are far away from the MRI head
Parameters
----------
distance : float
Exclude all points that are further away from the MRI head than
this distance. Previously excluded points are still excluded unless
reset=True is specified. A value of distance <= 0 excludes nothing.
reset : bool
Reset the filter before calculating new omission (default is
False).
"""
distance = float(distance)
if reset:
logger.info("Coregistration: Reset excluded head shape points")
with warnings.catch_warnings(record=True): # Traits None comp
self.hsp.points_filter = None
if distance <= 0:
return
# find the new filter
hsp_pts = self.transformed_hsp_points
mri_pts = self.transformed_mri_points
point_distance = _point_cloud_error(hsp_pts, mri_pts)
new_sub_filter = point_distance <= distance
n_excluded = np.sum(new_sub_filter == False) # noqa
logger.info("Coregistration: Excluding %i head shape points with "
"distance >= %.3f m.", n_excluded, distance)
# combine the new filter with the previous filter
old_filter = self.hsp.points_filter
if old_filter is None:
new_filter = new_sub_filter
else:
new_filter = np.ones(len(self.hsp.raw_points), np.bool8)
new_filter[old_filter] = new_sub_filter
# set the filter
with warnings.catch_warnings(record=True): # comp to None in Traits
self.hsp.points_filter = new_filter Example 6
def execute(self):
self.resulting_image = None
f_first = True
resimg = self.images_iterator.read_reference_image()
shape = resimg.shape
resimg.image[:] = 2**resimg.color_depth / 2
avrimg = Image(ishape=shape, dtype=resimg.dtype)
std = np.zeros(shape[:2], dtype=resimg.dtype) + 2**resimg.color_depth
dist = np.zeros(shape[:2], dtype=resimg.dtype)
flags = np.zeros(shape[:2], dtype=np.bool8)
iter_cnt = 5
for itr in range(iter_cnt):
invalid_imgs = []
img_cnt = 0.0
for imgarr in self.images_iterator:
if shape != imgarr.shape:
self.images_iterator.discard_image()
continue
img_cnt += 1
dist[:] = np.sqrt(
np.power(resimg.image[:, :, 0] - imgarr.image[:, :, 0], 2) +
np.power(resimg.image[:, :, 1] - imgarr.image[:, :, 1], 2) +
np.power(resimg.image[:, :, 2] - imgarr.image[:, :, 2], 2))
ca = time.clock()
flags[:] = False
flags[:] = dist[:] < std[:] / np.exp(np.float(itr) / 10.0)
avrimg.image[flags] = avrimg.image[flags] + imgarr.image[flags]
flags[:] = np.logical_not(flags)
avrimg.image[flags] = avrimg.image[flags] + resimg.image[flags]
cb = time.clock()
print(cb - ca)
resimg.image[:] = avrimg.image[:] / img_cnt
std[:] = 0.0
for imgarr in self.images_iterator:
std[:] = (std[:] +
(np.power(resimg.image[:, :, 0] - imgarr.image[:, :, 0], 2) +
np.power(resimg.image[:, :, 1] - imgarr.image[:, :, 1], 2) +
np.power(resimg.image[:, :, 2] - imgarr.image[:, :, 2], 2)))
std[:] = np.sqrt(std[:] / img_cnt)
avrimg.image[:] = 0.0
self.resulting_image = resimg 