def makeEllipticalFlatTop(self,mx,my,rx,ry) :
print "Intensity:Intensity2D:makeEllipticalFlatTop",mx,my,rx,ry
mx = pl.double(mx)
my = pl.double(my)
rx = pl.double(rx)
ry = pl.double(ry)
self.i = pl.complex64( ((self.xgrid-mx)/rx)**2 + ((self.ygrid-my)/ry)**2 <= 1.0)
def makeRectangularFlatTop(self, mx, my, rx, ry):
print "Intensity:Intensity2D:makeRectangularFlatTop", mx, my, rx, ry
rx = pl.double(rx)
ry = pl.double(ry)
a = rx * ry
self.i = pl.complex128(
(self.xgrid >= -rx / 2 + mx) & (self.xgrid <= rx / 2 + mx)
& (self.ygrid >= -ry / 2 + my) & (self.ygrid <= ry / 2 + my)) / a
def makeEllipticalFlatTop(self, mx, my, rx, ry):
print "Intensity:Intensity2D:makeEllipticalFlatTop", mx, my, rx, ry
mx = pl.double(mx)
my = pl.double(my)
rx = pl.double(rx)
ry = pl.double(ry)
self.i = pl.complex64(((self.xgrid - mx) / rx)**2 +
((self.ygrid - my) / ry)**2 <= 1.0)
def ExtraFromString(s):
s = s.strip(" \n")
lines = [l.strip(" \n") for l in s.split('\n')]
lines.pop(0)
tvect = []
torques = []
for i in range(len(lines) / 2):
tvect.append(double(lines[2 * i]))
torques.append(array([double(x) for x in lines[2 * i + 1].split(' ')]))
return array(tvect), array(torques)
def makeRectangularFlatTop(self,mx,my,rx,ry) :
print "Intensity:Intensity2D:makeRectangularFlatTop",mx,my,rx,ry
rx = pl.double(rx)
ry = pl.double(ry)
a = rx*ry
self.i = pl.complex128( (self.xgrid>=-rx/2+mx) &
(self.xgrid<=rx/2+mx) &
(self.ygrid>=-ry/2+my) &
(self.ygrid<=ry/2+my) )/a
def ExtraFromString(s):
s = s.strip(" \n")
lines = [l.strip(" \n") for l in s.split('\n')]
lines.pop(0)
tvect = []
torques = []
for i in range(len(lines) / 2):
tvect.append(double(lines[2 * i]))
torques.append(array([double(x) for x in lines[2 * i + 1].split(' ')]))
return array(tvect), array(torques)
def ProfileFromLines(lines):
l = lines[0]
[duration, dt] = [double(x) for x in l.split(' ')]
if duration<= 0 :
return None
l = lines[1]
sarray = array([double(x) for x in l.split(' ')])
l = lines[2]
sdarray = array([double(x) for x in l.split(' ')])
return [duration, dt, sarray, sdarray]
def ProfileFromLines(lines):
l = lines[0]
[duration, dt] = [double(x) for x in l.split(' ')]
if duration <= 0:
return None
l = lines[1]
sarray = array([double(x) for x in l.split(' ')])
l = lines[2]
sdarray = array([double(x) for x in l.split(' ')])
return [duration, dt, sarray, sdarray]
def loadMNISTImages(filename):
f = open(filename, 'rb')
# Verify Magic Number
s = f.read(4)
magic = int(s.encode('hex'),16)
assert(magic == 2051)
# Get Number of Images
s = f.read(4)
numImages = int(s.encode('hex'),16)
s = f.read(4)
numRows = int(s.encode('hex'),16)
s = f.read(4)
numCols = int(s.encode('hex'),16)
# Get Data
s = f.read()
a = frombuffer(s, uint8)
# Use 'F' to ensure that we read by column
a = reshape(a, (numCols , numRows, numImages), order='F');
images = transpose(a, (1, 0, 2))
f.close()
# Reshape to #pixels * #examples
images = reshape(a, (shape(images)[0] * shape(images)[1], numImages),
order='F');
images = double(images)/255
return images
def __init__(self,
nx = 5012, startx = -1e-3, endx = 1e-3,
ny = 5012, starty = -1e-3, endy = 1e-3,
wl=532e-9) :
self.nx = nx
self.startx = pl.double(startx)
self.endx = pl.double(endx)
self.ny = ny
self.starty = pl.double(starty)
self.endy = pl.double(endy)
self.wl = wl
print "Intensity:Intensity2D:__init__",self.nx,self.startx,self.endx,self.ny,self.starty,self.endy,self.wl
# make grid
self.grid()
def mk_zip_code_map():
'''
Parse zip code data
Returns: map from zipcode to (latitude, longitude)
'''
rv = {}
for z in open("zipcodes/zipcode.csv").readlines()[1:]:
z = z.strip(string.whitespace)
if z == "":
continue
zip = z.strip().split(",")
zipcode = zip[0][1:-1]
lat = pylab.double(zip[3][1:-1])
lon = pylab.double(zip[4][1:-1])
rv[zipcode] = (lat,lon)
return rv
def FromString(trajectorystring):
buff = StringIO.StringIO(trajectorystring)
chunkslist = []
while buff.pos < buff.len:
duration = double(buff.readline())
dimension = int(buff.readline())
poly_vector = []
for i in range(dimension):
poly_vector.append(Polynomial.FromString(buff.readline()))
chunkslist.append(Chunk(duration, poly_vector))
return PiecewisePolynomialTrajectory(chunkslist)
def __init__(self,
nx=5012,
startx=-1e-3,
endx=1e-3,
ny=5012,
starty=-1e-3,
endy=1e-3,
wl=532e-9):
self.nx = nx
self.startx = pl.double(startx)
self.endx = pl.double(endx)
self.ny = ny
self.starty = pl.double(starty)
self.endy = pl.double(endy)
self.wl = wl
print "Intensity:Intensity2D:__init__", self.nx, self.startx, self.endx, self.ny, self.starty, self.endy, self.wl
# make grid
self.grid()
def FromString(trajectorystring):
buff = io.StringIO(text_type(trajectorystring))
chunkslist = []
while buff.tell() < len(trajectorystring):
duration = double(buff.readline())
dimension = int(buff.readline())
poly_vector = []
for i in range(dimension):
poly_vector.append(Polynomial.FromString(buff.readline()))
chunkslist.append(Chunk(duration, poly_vector))
return PiecewisePolynomialTrajectory(chunkslist)
def FromString(trajectorystring):
buff = io.StringIO(trajectorystring)
chunkslist = []
while True:
read_line = buff.readline()
if read_line == '':
break
duration = double(read_line)
dimension = int(buff.readline())
poly_vector = []
for i in range(dimension):
poly_vector.append(Polynomial.FromString(buff.readline()))
chunkslist.append(Chunk(duration, poly_vector))
return PiecewisePolynomialTrajectory(chunkslist)
def fromString(self, s):
buff = StringIO(s)
self.vertices = []
while (True):
l = buff.readline()
l = l.strip(" \n")
if len(l) < 2:
break
x, y = [double(x) for x in l.split(' ')]
vnew = Vertex([x, y])
self.vertices.append(vnew)
for i in range(len(self.vertices) - 1):
self.vertices[i].next = self.vertices[i + 1]
self.vertices[-1].next = self.vertices[0]
def fromString(self, s):
buff = StringIO(s)
self.vertices = []
while(True):
l = buff.readline()
l = l.strip(" \n")
if len(l) < 2:
break
x, y = [double(x) for x in l.split(' ')]
vnew = Vertex([x, y])
self.vertices.append(vnew)
for i in range(len(self.vertices)-1):
self.vertices[i].next = self.vertices[i+1]
self.vertices[-1].next = self.vertices[0]
def computePerformance(self,idx=None,round_prec=4):
if(idx==None):
trials = self.trials
else:
trials = [trial for trial in self.trials if (trial.target_index==idx)];
trial_types = sorted(pl.unique([round(trial.target_contrast,round_prec) for trial in trials]));
scores = [[] for i in trial_types];
for trial in trials:
for i,trial_type in enumerate(trial_types):
if(round(trial.target_contrast,round_prec)==trial_type):
scores[i].append(trial.score);
ks = pl.array([sum(el) for el in scores]);
ns = pl.array([len(el) for el in scores]);
xs = trial_types;
ps = ks/pl.double(ns);
return pl.array([xs,ks,ns]);
def plotPerformance(self,idx=None,fixed_slope=None):
x,k,n = self.computePerformance(idx,round_prec=4);
thresh,slope = weibFit(x,k,n,fixed_slope);
# Now estimate lapse rate by computing 99% threshold and computing the proportion
# of errors made at contrasts above that threshold
t99 = invPsyWeib(.99,thresh,slope);
if t99<max(x):
lapse_rate = 0.0
else:
lapse_rate = 1.0-float(sum((x>t99)*k))/sum((x>t99)*n);
# For plotting purposes, recompute performance parameters after rounding contrasts
# to nearest percent.
x,k,n = self.computePerformance(idx,round_prec=2);
p = pl.double(k)/n;
fig = plt.figure();
if(idx!=None):
fig.suptitle('Theta = %2.0f deg.'%((idx-1)*45));
ax1 = fig.add_subplot(2,1,1);
ax2 = fig.add_subplot(2,1,2);
ax1.plot(x,p,'bo',x,psyWeib(x,thresh,slope),'b-',lw=2.0);
ax1.set_xlim(0,0.5);
ax1.xaxis.set_ticklabels([])
ax1.set_yticks(pl.linspace(0.4,1.0,4));
ax1.set_ylim(0.4,1.0);
ax1.set_ylabel('p(correct)');
ax1.text(0.38,0.65,r'$\hat{\alpha}$'+' = %2.3f'%thresh);
ax1.text(0.38,0.58,r'$\hat{\beta}$' +' = %2.2f'%slope);
ax1.text(0.38,0.51,r'$\hat{\lambda}$' +' = %2.3f'%lapse_rate);
ax1.text(0.38,0.44,r'$n$' +' = %2.0f'%sum(n));
ylim = pl.array(ax1.get_ylim());
ax1.vlines([thresh,t99],ylim.min(),ylim.max(),colors=['k','0.5'],linestyles='dashed');
ax1.text(thresh+0.01,0.41,r'$c_{\ 0.82}$' +' = %2.2f'%thresh);
ax1.text(t99+0.01,0.50,r'$c_{\ 0.99}$' +' = %2.2f'%t99,color='0.5');
ax2.bar(x-0.01,n,0.01);
ylim = pl.array(ax2.get_ylim());
ax2.vlines(thresh,ylim.min(),ylim.max(),colors = 'k',linestyles='dashed');
ax2.set_xlim(0,0.5);
ax2.set_ylabel('Contrast freq.');
ax2.set_xlabel('Target contrast');
plt.show();
ra = t.array['RA']
dec = t.array['Dec']
name = t.array['Name']
d = t.array['D']
num = len(ra)
# Make some output
f = open(outfile, 'w')
tout = '#Index\tName\tRA\tDec\tD\t'
tout += 'X\tY\tZ\n'
f.write(tout)
# Calculate for all
for i in range(len(ra)):
print ra[i], dec[i], d[i]
x, y, z = xyz(double(ra[i]), double(dec[i]), double(d[i]))
# print x,y,z
na = name[i]
na = na.replace(' ', '_')
tout = '%2d\t"%s"\t%3.10f\t%3.10f\t%3.2f\t' % ((i + 1), na, ra[i], dec[i], double(d[i]))
tout += '%3.2f\t%3.2f\t%3.2f\n' % (x, y, z)
print tout
f.write(tout)
f.close()
def FromString(polynomial_string):
s = polynomial_string.strip(" \n")
coeff_list = [double(x) for x in s.split(' ')]
return Polynomial(coeff_list)
def VectorFromString(s):
# left for compatibility TODO: remove?
s = s.strip(" \n")
return array([double(x) for x in s.split(' ')])
def FromString(polynomial_string):
s = polynomial_string.strip(" \n")
coeff_list = [double(x) for x in s.split(' ')]
return Polynomial(coeff_list)
reader = csv.reader(csvfile, delimiter = ' ')
for row in reader:
testfilenames.append(row[0])
num_test=len(testfilenames)
# prepare net
net = None
net = caffe.Net(model_def,model_weights,caffe.TEST)
batch_size,numchannel,crop_h,crop_w = net.blobs['data'].data.shape
caffe.set_mode_gpu()
# calculate batches
fi = 0
num_batches = np.floor(num_test/batch_size).astype(np.int)+1
#prob = np.zeros((batch_size*num_batches,crop_h,crop_w),np.float)
cvimg = np.zeros((crop_h,crop_w,3),np.uint8)
for ibatch in range(num_batches):
print [pylab.double(ibatch)/num_batches, batch_size]
output = net.forward()
# prob[ibatch*batch_size:(ibatch+1)*batch_size,:,:] = output['prob'][:,1,:,:]
for i in range(batch_size):
if fi < num_test:
img = (output['prob'][i,1,:,:] * 255).astype(np.uint8)
cvimg[:,:,0] = img
cv2.imwrite(resultfolder+'mask_'+testfilenames[fi], cvimg)
fi += 1
#prob=prob[0:num_test,:,:]
#np.save(resultfolder+'segprob.npy',prob)
def VectorFromString(s):
# left for compatibility TODO: remove?
s = s.strip(" \n")
return array([double(x) for x in s.split(' ')])
