# Python numpy.transpose() Examples

The following are 30 code examples of numpy.transpose(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module , or try the search function .
Example #1
def similarity_label(self, words, normalization=True):
"""
you can calculate more than one word at the same time.
"""
if self.model==None:
raise Exception('no model.')
if isinstance(words, string_types):
words=[words]
vectors=np.transpose(self.model.wv.__getitem__(words))
if normalization:
unit_vector=unitvec(vectors,ax=0) # 这样写比原来那样速度提升一倍
#unit_vector=np.zeros((len(vectors),len(words)))
#for i in range(len(words)):
#    unit_vector[:,i]=matutils.unitvec(vectors[:,i])
dists=np.dot(self.Label_vec_u, unit_vector)
else:
dists=np.dot(self.Label_vec, vectors)
return dists
Example #2
def train_lr_rfeinman(densities_pos, densities_neg, uncerts_pos, uncerts_neg):
"""
TODO
:param densities_pos:
:param densities_neg:
:param uncerts_pos:
:param uncerts_neg:
:return:
"""
values_neg = np.concatenate(
(densities_neg.reshape((1, -1)),
uncerts_neg.reshape((1, -1))),
axis=0).transpose([1, 0])
values_pos = np.concatenate(
(densities_pos.reshape((1, -1)),
uncerts_pos.reshape((1, -1))),
axis=0).transpose([1, 0])

values = np.concatenate((values_neg, values_pos))
labels = np.concatenate(
(np.zeros_like(densities_neg), np.ones_like(densities_pos)))

lr = LogisticRegressionCV(n_jobs=-1).fit(values, labels)

return values, labels, lr
Example #3
def train(self, inputs_list, targets_list):
inputs = np.array(inputs_list, ndmin=2).T
targets = np.array(targets_list, ndmin=2).T

hidden_inputs = np.dot(self.wih, inputs)
hidden_outputs = self.activation_function(hidden_inputs)

final_inputs = np.dot(self.who, hidden_outputs)
final_outputs = self.activation_function(final_inputs)

output_errors = targets - final_outputs
hidden_errors = np.dot(self.who.T, output_errors)

self.who += self.lr * np.dot((output_errors *
final_outputs *
(1.0 - final_outputs)), np.transpose(hidden_outputs))
self.wih += self.lr * np.dot((hidden_errors *
hidden_outputs *
(1.0 - hidden_outputs)), np.transpose(inputs))

pass

# query
Example #4
def jacobian(self, p, into=None):
# transpose to be 3 x 2 x n
p = np.transpose(np.reshape(p, (-1, 3, 2)), (1,2,0))
# First, get the two legs...
(dx_ab, dy_ab) = p[1] - p[0]
(dx_ac, dy_ac) = p[2] - p[0]
(dx_bc, dy_bc) = p[2] - p[1]
# now, the area is half the z-value of the cross-product...
sarea0 = 0.5 * (dx_ab*dy_ac - dx_ac*dy_ab)
# but we want to abs it
dsarea0 = np.sign(sarea0)
z = np.transpose([[-dy_bc,dx_bc], [dy_ac,-dx_ac], [-dy_ab,dx_ab]], (2,0,1))
z = times(0.5*dsarea0, z)
m = numel(p)
n = p.shape[2]
ii = (np.arange(n) * np.ones([6, n])).T.flatten()
z = sps.csr_matrix((z.flatten(), (ii, np.arange(len(ii)))), shape=(n, m))
return safe_into(into, z)
Example #5
def from_logeccen(logecc, vmin=0, vmax=90, offset=0.75):
'''
from_logeccen(logecc) yields a rescaled linear-space version of the log-eccentricity value (or
values) logecc.
from_logeccen(logxy_matrix) rescales all the (x,y) points in the given matrix to have
linearly-spaced eccentricity values.

from_logeccen is the inverse of to_logeccen.
'''
if pimms.is_matrix(logecc):
xy = np.asarray(logecc)
trq = xy.shape[0] != 2
xy = np.transpose(xy) if trq else np.asarray(xy)
r = np.sqrt(np.sum(xy**2, axis=0))
esc = from_logeccen(r, vmin=vmin, vmax=vmax, offset=offset)
ecc = zinv(r)
xy = xy * [ecc,ecc] * [esc,esc]
return xy.T if trq else xy
else:
logecc = np.asarray(logecc)
(vmin,vmax,offset) = [np.asarray(u) for u in (vmin,vmax,offset)]
(vmin, vmax) = [np.log(u + offset) for u in (vmin, vmax)]
logecc = logecc*(vmax - vmin) + vmin
return np.exp(logecc) - offset
Example #6
def __call__(self, x, y=None):
if y is not None: x = (x,y)
x = np.asarray(x)
if len(x.shape) == 1: return self([x])[0]
x = np.transpose(x) if x.shape[0] == 2 else x
if not x.flags['WRITEABLE']: x = np.array(x)
crd = self.coordinates
sig = self.sigma
wts = self._weight
res = np.zeros(x.shape[0])
for (sh, qd, bi) in zip(self.spatial_hashes, self.bin_query_distances, self.sigma_bins):
neis = sh.query_ball_point(x, qd)
res += [
np.sum(w * np.exp(-0.5 * d2/s**2))
for (ni,pt) in zip(neis,x)
for ii in [bi[ni]]
for (w,s,d2) in [(wts[ii], sig[ii], np.sum((crd[ii] - pt)**2, axis=1))]]
return res
Example #7
def visualize_sampling(self, permutations):
max_length = len(permutations[0])
grid = np.zeros([max_length,max_length]) # initialize heatmap grid to 0

transposed_permutations = np.transpose(permutations)
for t, cities_t in enumerate(transposed_permutations): # step t, cities chosen at step t
city_indices, counts = np.unique(cities_t,return_counts=True,axis=0)
for u,v in zip(city_indices, counts):
grid[t][u]+=v # update grid with counts from the batch of permutations

# plot heatmap
fig = plt.figure()
rcParams.update({'font.size': 22})
ax.set_aspect('equal')
plt.imshow(grid, interpolation='nearest', cmap='gray')
plt.colorbar()
plt.title('Sampled permutations')
plt.ylabel('Time t')
plt.xlabel('City i')
plt.show()
Example #8
def superpose_array(refArray, array, check=False):
"""
Superpose arrays by calculating the rotation matrix and the
translations that minimize the root mean square deviation between and
array of vectors and a reference array.

:Parameters:
#. refArray (numpy.ndarray): the NX3 reference array to superpose to.
#. array (numpy.ndarray): the NX3 array to calculate the
transformation of.
#. check (boolean): whether to check arguments before generating
points.

:Returns:
#. superposedArray (numpy.ndarray): the NX3 array to superposed array.
"""
rotationMatrix, _,_,_ = get_superposition_transformation(refArray=refArray, array=array, check=check)
return np.dot( rotationMatrix, np.transpose(array).\
reshape(1,3,-1)).transpose().reshape(-1,3)
Example #9
def measure_cost(repeat, scipy_trans_lhs, scipy_dns_lhs, func_name, *args, **kwargs):
"""Measure time cost of running a function
"""
mx.nd.waitall()
args_list = []
for arg in args:
args_list.append(arg)
start = time.time()
if scipy_trans_lhs:
args_list[0] = np.transpose(args_list[0]) if scipy_dns_lhs else sp.spmatrix.transpose(args_list[0])
for _ in range(repeat):
func_name(*args_list, **kwargs)
mx.nd.waitall()
end = time.time()
diff = end - start
return diff / repeat
Example #10
def decode_topk(self, sess, latest_tokens, enc_top_states, dec_init_states):
"""Return the topK results and new decoder states."""
feed = {
self._enc_top_states: enc_top_states,
self._dec_in_state:
np.squeeze(np.array(dec_init_states)),
self._abstracts:
np.transpose(np.array([latest_tokens])),
self._abstract_lens: np.ones([len(dec_init_states)], np.int32)}

results = sess.run(
[self._topk_ids, self._topk_log_probs, self._dec_out_state],
feed_dict=feed)

ids, probs, states = results[0], results[1], results[2]
new_states = [s for s in states]
return ids, probs, new_states
Example #11
def _write_map_files(b_in, b_out, transform):
cats = get_categories()

valid_min=-10, valid_max=200, n_samples_per_face=200)
robot = utils.Foo(radius=15, base=10, height=140, sensor_height=120,
camera_elevation_degree=-15)

for flip in [False, True]:
b = nav_env.Building(b_out, robot, env, flip=flip,
logging.info("building_in: %s, building_out: %s, transform: %d", b_in,
b_out, transform)
maps = _get_semantic_maps(b_in, transform, b.map, flip, cats)
maps = np.transpose(np.array(maps), axes=[1,2,0])

#  Load file from the cache.
file_name = '{:s}_{:d}_{:d}_{:d}_{:d}_{:d}_{:d}.pkl'
file_name = file_name.format(b.building_name, b.map.size[0], b.map.size[1],
b.map.origin[0], b.map.origin[1],
b.map.resolution, flip)
out_file = os.path.join(DATA_DIR, 'processing', 'class-maps', file_name)
logging.info('Writing semantic maps to %s.', out_file)
save_variables(out_file, [maps, cats], ['maps', 'cats'], overwrite=True)
Example #12
def intersection(boxes1, boxes2):
"""Compute pairwise intersection areas between boxes.

Args:
boxes1: a numpy array with shape [N, 4] holding N boxes
boxes2: a numpy array with shape [M, 4] holding M boxes

Returns:
a numpy array with shape [N*M] representing pairwise intersection area
"""
[y_min1, x_min1, y_max1, x_max1] = np.split(boxes1, 4, axis=1)
[y_min2, x_min2, y_max2, x_max2] = np.split(boxes2, 4, axis=1)

all_pairs_min_ymax = np.minimum(y_max1, np.transpose(y_max2))
all_pairs_max_ymin = np.maximum(y_min1, np.transpose(y_min2))
intersect_heights = np.maximum(
np.zeros(all_pairs_max_ymin.shape),
all_pairs_min_ymax - all_pairs_max_ymin)
all_pairs_min_xmax = np.minimum(x_max1, np.transpose(x_max2))
all_pairs_max_xmin = np.maximum(x_min1, np.transpose(x_min2))
intersect_widths = np.maximum(
np.zeros(all_pairs_max_xmin.shape),
all_pairs_min_xmax - all_pairs_max_xmin)
return intersect_heights * intersect_widths
Example #13
def collectdata(self,):
print 'Start Collect Data...'

train_x_path = os.path.join(self.input_dir, 'unlabeled_X.bin')

train_xf = open(train_x_path, 'rb')
train_x = np.fromfile(train_xf, dtype=np.uint8)
train_x = np.reshape(train_x, (-1, 3, 96, 96))
train_x = np.transpose(train_x, (0, 3, 2, 1))

idx = 0
for i in xrange(train_x.shape[0]):
if not self.skipimg:
transform_and_save(img_arr=train_x[i], output_filename=os.path.join(self.unlabeldir, str(idx) + '.jpg'))
self.trainpairlist[os.path.join('images', 'unlabeled', str(idx) + '.jpg')] = 'labels/11.txt'
idx += 1

print 'Finished Collect Data...'
Example #14
def pre_processing(obs, cuda):
mean = np.array([0.485, 0.456, 0.406]).reshape([1, 1, 3])
std = np.array([0.229, 0.224, 0.225]).reshape([1, 1, 3])
obs = obs / 255
obs = (obs - mean) / std
obs = np.transpose(obs, (2, 0, 1))
obs = np.expand_dims(obs, 0)
obs = np.array(obs)
if cuda:
torch_device = torch.device('cuda:0')
else:
torch_device = torch.device('cpu')
obs_tensor = torch.tensor(obs, dtype=torch.float32, device=torch_device, requires_grad=True)
return obs_tensor

# generate the entire images
Example #15
def resample(imgs, spacing, new_spacing,order=2):
if len(imgs.shape)==3:
new_shape = np.round(imgs.shape * spacing / new_spacing)
true_spacing = spacing * imgs.shape / new_shape
resize_factor = new_shape / imgs.shape
imgs = zoom(imgs, resize_factor, mode = 'nearest',order=order)
return imgs, true_spacing
elif len(imgs.shape)==4:
n = imgs.shape[-1]
newimg = []
for i in range(n):
slice = imgs[:,:,:,i]
newslice,true_spacing = resample(slice,spacing,new_spacing)
newimg.append(newslice)
newimg=np.transpose(np.array(newimg),[1,2,3,0])
return newimg,true_spacing
else:
raise ValueError('wrong shape')
Example #16
def intersection(boxes1, boxes2):
"""Compute pairwise intersection areas between boxes.

Args:
boxes1: a numpy array with shape [N, 4] holding N boxes
boxes2: a numpy array with shape [M, 4] holding M boxes

Returns:
a numpy array with shape [N*M] representing pairwise intersection area
"""
[y_min1, x_min1, y_max1, x_max1] = np.split(boxes1, 4, axis=1)
[y_min2, x_min2, y_max2, x_max2] = np.split(boxes2, 4, axis=1)

all_pairs_min_ymax = np.minimum(y_max1, np.transpose(y_max2))
all_pairs_max_ymin = np.maximum(y_min1, np.transpose(y_min2))
intersect_heights = np.maximum(
np.zeros(all_pairs_max_ymin.shape),
all_pairs_min_ymax - all_pairs_max_ymin)
all_pairs_min_xmax = np.minimum(x_max1, np.transpose(x_max2))
all_pairs_max_xmin = np.maximum(x_min1, np.transpose(x_min2))
intersect_widths = np.maximum(
np.zeros(all_pairs_max_xmin.shape),
all_pairs_min_xmax - all_pairs_max_xmin)
return intersect_heights * intersect_widths
Example #17
def load_batch_norm(idx, variables, weights, assign_ops, offset):
"""Loads kernel, gamma, beta, mean, variance for Batch Normalization"""
kernel = variables[idx]
gamma, beta, mean, variance = variables[idx + 1:idx + 5]
batch_norm_vars = [beta, gamma, mean, variance]

for var in batch_norm_vars:
shape = var.shape.as_list()
num_params = np.prod(shape)
var_weights = weights[offset:offset + num_params].reshape(shape)
offset += num_params
assign_ops.append(tf.assign(var, var_weights))

shape = kernel.shape.as_list()
num_params = np.prod(shape)
var_weights = weights[offset:offset + num_params].reshape((shape[3], shape[2], shape[0], shape[1]))
var_weights = np.transpose(var_weights, (2, 3, 1, 0))
offset += num_params
assign_ops.append(tf.assign(kernel, var_weights))
return assign_ops, offset
Example #18
def lid_term(logits, batch_size=100):
"""Calculate LID loss term for a minibatch of logits

:param logits:
:return:
"""
# y_pred = tf.nn.softmax(logits)
y_pred = logits

# calculate pairwise distance
r = tf.reduce_sum(y_pred * y_pred, 1)
# turn r into column vector
r1 = tf.reshape(r, [-1, 1])
D = r1 - 2 * tf.matmul(y_pred, tf.transpose(y_pred)) + tf.transpose(r1) + \
tf.ones([batch_size, batch_size])

# find the k nearest neighbor
D1 = -tf.sqrt(D)
D2, _ = tf.nn.top_k(D1, k=21, sorted=True)
D3 = -D2[:, 1:]

m = tf.transpose(tf.multiply(tf.transpose(D3), 1.0 / D3[:, -1]))
v_log = tf.reduce_sum(tf.log(m + 1e-9), axis=1)  # to avoid nan
lids = -20 / v_log

## batch normalize lids
# lids = tf.nn.l2_normalize(lids, dim=0, epsilon=1e-12)

return lids
Example #19
"""Calculate LID loss term for a minibatch of advs logits

:param logits: clean logits
:return:
"""
# y_pred = tf.nn.softmax(logits)
c_pred = tf.reshape(clean_logits, (batch_size, -1))

# calculate pairwise distance
r = tf.reduce_sum(c_pred * a_pred, 1)
# turn r into column vector
r1 = tf.reshape(r, [-1, 1])
D = r1 - 2 * tf.matmul(c_pred, tf.transpose(a_pred)) + tf.transpose(r1) + \
tf.ones([batch_size, batch_size])

# find the k nearest neighbor
D1 = -tf.sqrt(D)
D2, _ = tf.nn.top_k(D1, k=21, sorted=True)
D3 = -D2[:, 1:]

m = tf.transpose(tf.multiply(tf.transpose(D3), 1.0 / D3[:, -1]))
v_log = tf.reduce_sum(tf.log(m + 1e-9), axis=1)  # to avoid nan
lids = -20 / v_log

## batch normalize lids
lids = tf.nn.l2_normalize(lids, dim=0, epsilon=1e-12)

return lids
Example #20
def make_image(img, mean=(0,0,0), std=(1,1,1)):
for i in range(0, 3):
img[i] = img[i] * std[i] + mean[i]    # unnormalize
npimg = img.numpy()
return np.transpose(npimg, (1, 2, 0))
Example #21
def end(self, success=True):
from neuropythy import path_trace
# we've finished; clean up and make the line
if success:
if len(self.xs) < 1: raise ValueError('Drawn line has no points')
pts = np.transpose([self.xs, self.ys])
# remove us from the trace meta-data if we're in it
rd = self.trace.meta_data.get('roi_drawer')
if rd is self: self.trace.meta_data = self.trace.meta_data.discard('roi_drawer')
self.trace.persist()
else: self.trace = None
if self.line:
for conn in self.connections:
self.line.figure.canvas.mpl_disconnect(conn)
# redraw the final version:
if self.closed:
self.xs.append(self.xs[0])
self.ys.append(self.ys[0])
self.line.set_data(self.xs, self.ys)
self.line.figure.canvas.draw()
matplotlib.pyplot.close(self.line.figure)
# clear everything
self.connection = None
self.line = None
self.xs = None
self.ys = None
Example #22
'''
sub.lh_white_indices is a frozenset of the indices of the white voxels in the given
subject's lh, represented as 3-tuples.
'''
if lh_white_mask is None: return None
return frozenset([tuple(row) for row in idcs])
Example #23
'''
sub.rh_white_indices is a frozenset of the indices of the white voxels in the given
subject's rh, represented as 3-tuples.
'''
if rh_white_mask is None: return None
return frozenset([tuple(row) for row in idcs])
Example #24
'''
if address is singular, the 3D vector) in the given cortex. If the address is a 2D instead
of a 3D address, then the mid-gray position is returned by default.

The following options may be given:
* surface (default: 0.5) specifies the surface to use for 2D addresses; this should be
either 'white', 'pial', 'midgray', or a real number in the range [0,1] where 0 is the
white surface and 1 is the pial surface.
'''
(faces, coords) = address_data(data, 3, surface=surface)
(bc, ds) = (coords[:2], coords[2])
faces = self.tess.index(faces)
(wx, px) = (self.white_surface.coordinates, self.pial_surface.coordinates)
if all(len(np.shape(x)) > 1 for x in (faces, coords)):
(wtx, ptx) = [
np.transpose([sx[:,ff] if ff[0] >= 0 else null for ff in faces.T], (2,1,0))
for null in [np.full((3, wx.shape[0]), np.nan)]
for sx   in (wx, px)]
elif faces == -1:
return np.full(selfx.shape[0], np.nan)
else:
(wtx, ptx) = [sx[:,faces].T for sx in (wx, px)]
(wu, pu) = [geo.barycentric_to_cartesian(tx, bc) for tx in (wtx, ptx)]
return wu*ds + pu*(1 - ds)
Example #25
def line_segment_intersection_2D(p12arg, p34arg, atol=1e-8):
'''
line_segment_intersection((a, b), (c, d)) yields the intersection point between the line
passing through points a and b and the line segment that passes from point c to point d. If
there is no intersection point, then (numpy.nan, numpy.nan) is returned.
'''
(p1,p2) = p12arg
(p3,p4) = p34arg
pi = np.asarray(line_intersection_2D(p12arg, p34arg, atol=atol))
p3 = np.asarray(p3)
u34 = p4 - p3
cfn = lambda px,iis: (px if iis is None or len(px.shape) == 1 or px.shape[1] == len(iis) else
px[:,iis])
dfn = lambda a,b:     a[0]*b[0] + a[1]*b[1]
sfn = lambda a,b:     ((a-b)                 if len(a.shape) == len(b.shape) else
(np.transpose([a])-b) if len(a.shape) <  len(b.shape) else
(a - np.transpose([b])))
fn  = lambda px,iis:  (1 - ((dfn(cfn(u34,iis), sfn(         px, cfn(p3,iis))) > 0) *
(dfn(cfn(u34,iis), sfn(cfn(p4,iis),          px)) > 0)))
if len(pi.shape) == 1:
if not np.isfinite(pi[0]): return (np.nan, np.nan)
return (np.nan, np.nan) if bad else pi
else:
nonpar = np.where(np.isfinite(pi[0]))[0]
(xi,yi) = pi
return (xi,yi)
Example #26
def triangle_normal(a,b,c):
'''
triangle_normal(a, b, c) yields the normal vector of the triangle whose vertices are given by
the points a, b, and c. If the points are 2D points, then 3D normal vectors are still yielded,
that are always (0,0,1) or (0,0,-1). This function auto-threads over matrices, in which case
they must be in equivalent orientations, and the result is returned in whatever orientation
they are given in. In some cases, the intended orientation of the matrices is ambiguous (e.g.,
if a, b, and c are 2 x 3 matrices), in which case the matrix is always assumed to be given in
(dims x vertices) orientation.
'''
(a,b,c) = [np.asarray(x) for x in (a,b,c)]
if len(a.shape) == 1 and len(b.shape) == 1 and len(c.shape) == 1:
return triangle_normal(*[np.transpose([x]) for x in (a,b,c)])[:,0]
(a,b,c) = [np.transpose([x]) if len(x.shape) == 1 else x for x in (a,b,c)]
# find a required number of dimensions, if possible
if a.shape[0] in (2,3):
dims = a.shape[0]
tx = True
else:
dims = a.shape[1]
(a,b,c) = [x.T for x in (a,b,c)]
tx = False
n = (a.shape[1] if a.shape[1] != 1 else b.shape[1] if b.shape[1] != 1 else
c.shape[1] if c.shape[1] != 1 else 1)
if dims == 2:
(a,b,c) = [np.vstack((x, np.zeros((1,n)))) for x in (a,b,c)]
ab = normalize(b - a)
ac = normalize(c - a)
res = np.cross(ab, ac, axisa=0, axisb=0)
return res.T if tx else res
Example #27
def value(self, p):
# transpose to be 3 x 2 x n
p = np.transpose(np.reshape(p, (-1, 3, 2)), (1,2,0))
# First, get the two legs...
(dx_ab, dy_ab) = p[1] - p[0]
(dx_ac, dy_ac) = p[2] - p[0]
(dx_bc, dx_bc) = p[2] - p[1]
# now, the area is half the z-value of the cross-product...
sarea = 0.5 * (dx_ab*dy_ac - dx_ac*dy_ab)
return sarea
Example #28
def jacobian(self, p, into=None):
p = np.transpose(np.reshape(p, (-1, 3, 2)), (1,2,0))
(dx_ab, dy_ab) = p[1] - p[0]
(dx_ac, dy_ac) = p[2] - p[0]
(dx_bc, dy_bc) = p[2] - p[1]
z = 0.5 * np.transpose([[-dy_bc,dx_bc], [dy_ac,-dx_ac], [-dy_ab,dx_ab]], (2,0,1))
m = numel(p)
n = p.shape[2]
ii = (np.arange(n) * np.ones([6, n])).T.flatten()
z = sps.csr_matrix((z.flatten(), (ii, np.arange(len(ii)))), shape=(n, m))
return safe_into(into, z)
Example #29
def value(self, p):
# transpose to be 3 x 2 x n
p = np.transpose(np.reshape(p, (-1, 3, 2)), (1,2,0))
# First, get the two legs...
(dx_ab, dy_ab) = p[1] - p[0]
(dx_ac, dy_ac) = p[2] - p[0]
(dx_bc, dy_bc) = p[2] - p[1]
# now, the area is half the z-value of the cross-product...
sarea0 = 0.5 * (dx_ab*dy_ac - dx_ac*dy_ab)
# but we want to abs it
return np.abs(sarea0)
Example #30
def angle_to_cortex(self, theta, rho):
'See help(neuropythy.registration.RetinotopyModel.angle_to_cortex).'
#TODO: This should be made to work correctly with visual area boundaries: this could be done
# by, for each area (e.g., V2) looking at its boundaries (with V1 and V3) and flipping the
# adjacent triangles so that there is complete coverage of each hemifield, guaranteed.
if not pimms.is_vector(theta): return self.angle_to_cortex([theta], [rho])[0]
theta = np.asarray(theta)
rho = np.asarray(rho)
zs = np.asarray(
rho * np.exp([np.complex(z) for z in 1j * ((90.0 - theta)/180.0*np.pi)]),
dtype=np.complex)
coords = np.asarray([zs.real, zs.imag]).T
if coords.shape[0] == 0: return np.zeros((0, len(self.visual_meshes), 2))
# we step through each area in the forward model and return the appropriate values
tx = self.transform
res = np.transpose(
[self.visual_meshes[area].interpolate(coords, 'cortical_coordinates', method='linear')
for area in sorted(self.visual_meshes.keys())],
(1,0,2))
if tx is not None:
res = np.asarray(
[np.dot(tx, np.vstack((area_xy.T, np.ones(len(area_xy)))))[0:2].T
for area_xy in res])
return res