def get_calibration(fignum = 1, pct_wide = 0.2, pct_high = 0.33, tunneldicts=None): ax = pylab.figure(fignum).axes[0] ymax = round(ax.get_ybound()[1]) xmax = round(ax.get_xbound()[1]) pix_wide = ymax*pct_wide pix_high = ymax*pct_high print >> sys.stderr, 'image is %s x %s; windows will be %s, %s' % (xmax,ymax,pix_wide,pix_high) cm_dists = [] print >> sys.stderr, 'click 0, 1, 10 cm marks' pylab.xlim(0,pix_high) pylab.ylim(ymax,ymax-pix_wide) p0,p1,p10 = pylab.ginput(3,0) cm_dists.append(vidtools.hypotenuse(p0,p1)) cm_dists.append(vidtools.hypotenuse(p0,p10)/10.0) print >> sys.stderr, 'click 0, 1, 10 cm marks' pylab.xlim(xmax-pix_wide,xmax) pylab.ylim(pix_high,0) p0,p1,p10 = pylab.ginput(3,0) cm_dists.append(vidtools.hypotenuse(p0,p1)) cm_dists.append(vidtools.hypotenuse(p0,p10)/10.0) print >> sys.stderr, 'click bolt 1' pylab.xlim(0,pix_wide) pylab.ylim(ymax,ymax-pix_wide) horiz = [pylab.ginput(1,0)[0]] print >> sys.stderr, 'click bolt 2' pylab.xlim(xmax-pix_wide,xmax) pylab.ylim(ymax,ymax-pix_wide) horiz.append(pylab.ginput(1,0)[0]) pylab.xlim(0,xmax) pylab.ylim(ymax,0) if tunneldicts is not None: tunneldicts['cm_pts'] = cm_dists tunneldicts['horiz'] = horiz else: return cm_dists,horiz
def acquire_masks(self):
im1 = self.cam2.get()
pl.imshow(im1, cmap='gray')
pl.title('Select Eye')
pts_eye = pl.ginput(n=0, timeout=0)
pts_eye = np.array(pts_eye, dtype=np.int32)
mask_eye = np.zeros(im1.shape, dtype=np.int32)
cv2.fillConvexPoly(mask_eye, pts_eye, (1,1,1), lineType=cv2.LINE_AA)
pl.clf()
im2 = self.cam2.get()
pl.imshow(im2, cmap='gray')
pl.title('Select Wheel')
pl.gcf().canvas.draw()
pts_wheel = pl.ginput(n=0, timeout=0)
pts_wheel = np.array(pts_wheel, dtype=np.int32)
mask_wheel = np.zeros(im2.shape, dtype=np.int32)
cv2.fillConvexPoly(mask_wheel, pts_wheel, (1,1,1), lineType=cv2.LINE_AA)
pl.close()
self.mask = np.array([mask_eye, mask_wheel])
self.mask_flat = self.mask.reshape((2,-1))
return self.mask
def splitTrial(self, baseChannel):
self.baseChannel = baseChannel
self.ax.plot(self.rawData[self.baseChannel])
numElements = self.rawData.shape[0]
self.ax1 = plt.axes([0.0, 0.5, 0.1, 0.075])
self.b1 = Button(self.ax1, 'Submit')
self.b1.on_clicked(self.onSubmit)
begin = ginput(1)
end = ginput(1)
length = int(end[0][0] - begin[0][0])
self.iBegins = [int(begin[0][0]) + i * length for i in xrange(self.numTrials)]
self.iEnds = [int(begin[0][0]) + (i + 1) * length - 1 for i in xrange(self.numTrials)]
[minL, maxL] = getYValueLimits(self.rawData, self.baseChannel)
for iLine in xrange(self.numTrials):
self.endlines.append(self.ax.axvline(self.iEnds[iLine], 0, maxL, color='k', picker=5))
self.fig.canvas.mpl_connect('pick_event', self.onPick)
self.fig.canvas.mpl_connect('key_press_event', self.onKey)
# self.fig.canvas.draw()
plt.show()
def wait(msg=None):
"""Wait for the user to acknowledge the plot."""
import pylab
#from matplotlib.blocking_input import BlockingInput
if msg: print msg
#block = BlockingInput(fig=pylab.gcf(), eventslist=('key_press_event',))
#block(n=1, timeout=-1)
pylab.ginput()
def plotgrid(data,d=10,shape=(30,30)):
"""Plot a list of images on a grid."""
ion()
gray()
clf()
for i in range(min(d*d,len(data))):
subplot(d,d,i+1)
row = data[i]
if shape is not None: row = row.reshape(shape)
imshow(row)
ginput(1,timeout=0.1)
def touch_with_func():
plot_data = {}
read_data = CVMCv1Parser.from_file('cv1.txt')
for i in range(0, 1):
data = read_data.data[i]['data']
temp = read_data.data[i]['temp']
data.set_free_energy_00_from_logtxt('log.txt')
data.set_end_energy(0, 0)
err = make_err_func(func)
points = []
for j in range(15):
pylab.plot(data['comp1'], data['corrected_g'], '+')
pylab.axvline(x=1/16*(j+1), color='black')
try:
p = pylab.ginput(n=1, timeout=2)
while p == []:
p = pylab.ginput(n=1, timeout=2)
print(1/16*(j+1), p[0][1])
except KeyboardInterrupt:
print("座標習得を諦めました")
exit()
points.append(p[0])
pylab.close()
points = np.array(points)
param = optimize.leastsq(
err, [1, 1, 1, 1, 1], args=(points[:, 0],
points[:, 1]))[0]
judge = np.abs(err(param, data['comp1'], data['corrected_g'])) < 1
inliersx = data['comp1'][judge]
inliersy = data['corrected_g'][judge]
x = inliersx
y = inliersy
opt = optimize.leastsq(
err, [1, 1, 1, 1, 1], args=(x, y))[0]
fitx = np.linspace(0, 1, 100)
fity = func(opt, fitx)
plot_data.update({temp:[data['comp1'], data['corrected_g'], fitx, fity]})
i = 1
for temp in plot_data:
pd = plot_data[temp]
d = (33 // (len(plot_data) + 1))
pylab.plot(pd[0], pd[1], '+',
color=COLOR_PALETTE[d*i][1])
pylab.plot(pd[2], pd[3], color=COLOR_PALETTE[d*i][0], linewidth=2)
save_results(temp, pd)
i += 1
pylab.xlim(0, 1)
pylab.show()
def wincoord(winno):
cor1 = 1 ; cor2 = 0
while cor1 > cor2:
print("Please click at the start (left-side) of the window %d" % (winno))
cor1 = plt.ginput(1)[0][0]
print(cor1)
print("Please click at the end (right-side) of the window %d" % (winno))
cor2 = plt.ginput(1)[0][0]
print(cor2)
if cor1 > cor2:
#print('pixel coordinates of the start of the window is greater than the end! So lets restarts input for window ' % (winno))
# Check if coordinates were entered in Arabic fashion! Swap if needed.
cor1, cor2 = cor2, cor1
return round(cor1,0),round(cor2,0)
def get_terminus(self):
from matplotlib.widgets import Cursor
if self.mask_computed == True:
self.mask = dbg.initialize_mask(self.thk)
plt.clf()
plt.pcolormesh(self.x, self.y, self.mask)
plt.contour(self.x, self.y, self.z, colors='black')
plt.axis('tight')
plt.axes().set_aspect('equal')
plt.draw()
plt.setp(plt.gca(),autoscale_on=False)
cursor = Cursor(plt.axes(), useblit=True, color='white', linewidth=1 )
if self.ph is not None and self.mask_computed == False:
for p in self.ph:
p.remove()
self.ph = None
pts = []
while len(pts) < 4:
pts = np.asarray( plt.ginput(4, timeout=-1) )
self.ph = plt.fill(pts[:,0], pts[:,1], 'white', lw = 2, alpha=0.5)
plt.draw()
self.pts = pts
self.mask_computed = False
def _Delete_spectra_fired(self):
plt.figure()
plt.contourf(Data.wavelength, Data.time, Data.TrA_Data, 100)
plt.title('Pick between times to delete (top to bottom)')
plt.xlabel('Wavelength')
plt.ylabel('Time')
fittingto = np.array(ginput(2))
plt.show()
plt.close()
index_time_top=(np.abs(Data.time-fittingto[1,1])).argmin()
index_time_bottom=(np.abs(Data.time-fittingto[0,1])).argmin()+1
if index_time_bottom <= index_time_top:
hold = index_time_top
index_time_top = index_time_bottom
index_time_bottom = hold
if index_time_top == 0:
Data.TrA_Data = Data.TrA_Data[index_time_bottom:,:]
Data.time = Data.time[index_time_bottom:]
if index_time_bottom == Data.time.shape:
Data.TrA_Data = Data.TrA_Data[:index_time_top,:]
Data.time = Data.time[:index_time_top]
if index_time_top != 0 & index_time_bottom != Data.time.shape:
Data.TrA_Data = np.vstack((Data.TrA_Data[:index_time_top,:],Data.TrA_Data[index_time_bottom:,:]))
Data.time = np.hstack((Data.time[:index_time_top],Data.time[index_time_bottom:]))
self.log = "%s \nDeleted spectra between %s and %s" %(self.log,fittingto[0,1],fittingto[1,1])
def etch(self, refmask=[0]):
"""Cut away at surface. Can only click polygons for now.
Optionally input reference mask to guide etching.
"""
size = self.size
mask = n.ones((self.size,self.size), dtype='bool')
print 'Click for points of region to etch (right click to exit).'
p.figure(1)
if len(refmask) != 1:
p.imshow(n.transpose(-refmask), aspect='auto', origin='lower', interpolation='nearest', cmap=p.cm.Greys, extent=(0,1,0,1), vmax=0.5)
else:
p.imshow(n.transpose(-self.mask), aspect='auto', origin='lower', interpolation='nearest', cmap=p.cm.Greys, extent=(0,1,0,1), vmax=0.5)
xy = p.ginput(n=0, timeout=3000)
xy = n.array(xy)
print 'Calculating remaining region...'
p.figure(1)
p.axis([0,1,0,1])
p.fill(xy[:,0],xy[:,1],'k')
for i in range(size):
for j in range(size):
mask[i,j] = not(point_inside_polygon(float(i)/size, float(j)/size, xy))
self.mask = self.mask * mask
def select_valid_region_topView(frame_input):
inputFig = plt.figure()
plt.title('Select points to define valid regions:top View')
plt.imshow(frame_input, cmap = 'gray', interpolation = 'bicubic')
# Same as ginput() in Matlab
region_ptList = ginput(8)
plt.close(inputFig)
region_ptArray0 = np.asarray(region_ptList)
region_ptArray = region_ptArray0.astype(int)
region_ptArray = np.vstack((region_ptArray, region_ptArray[0,:]))
# Get the arms A,B,C,U
pointsLeft = region_ptArray[0:4,:]
maskLeft0 = np.zeros(frame_input.shape[:2],dtype = 'uint8')
cv2.drawContours(maskLeft0,[pointsLeft],0,255,-1)
maskLeft0 = cv2.cvtColor(maskLeft0,cv2.COLOR_GRAY2BGR)
maskLeft = cv2.cvtColor(maskLeft0,cv2.COLOR_BGR2GRAY)
pointsRight = region_ptArray[4:8,:]
maskRight0 = np.zeros(frame_input.shape[:2],dtype = 'uint8')
cv2.drawContours(maskRight0,[pointsRight],0,255,-1)
maskRight0 = cv2.cvtColor(maskRight0,cv2.COLOR_GRAY2BGR)
maskRight = cv2.cvtColor(maskRight0,cv2.COLOR_BGR2GRAY)
return maskLeft0, maskLeft, maskRight0, maskRight
def selectPoints(im1_path, im2_path):
im = Image.open(im1_path)
plt.imshow(im)
counter, f_points = constant.TOTAL_FEATURE, []
while counter != 0:
print "Click on screen!"
x = ginput(1)
counter -= 1
f_points.append([x[0][0], x[0][1]])
plt.scatter(x[0][0], x[0][1])
plt.draw()
print("Clicked point at ", x, " | Clicks left: ", counter)
plt.show()
second_points = drag_control_points(mpimg.imread(im2_path), np.array(f_points))
intermediate_feature = interpolatePts(combinePoints(f_points, second_points))
frames = combineImages(intermediate_feature, constant.TRIANGLES, im1_path, im2_path)
frames.extend(frames[::-1])
# otherone = [cv2.cvtColor(items, cv2.COLOR_RGB2BGR) for items in frames]
# writeGif("lol.GIF", otherone, duration=0.07)
while True:
for i in range (0, len(frames)):
f = frames[i]
cv2.waitKey(20)
cv2.imshow("Cameras",f)
cv2.waitKey(20)
def Main():
save_file_root = "C:\\Users\\Camera\\Desktop\\Video_Editing_Tools\\Analysis\\Set 8\\Limb_Movement"
load_video_filename = "C:\\Users\\Camera\\Desktop\\Video_Editing_Tools\\Analysis\\Set 8\\Median.avi"
# load_video_filename = "C:\\Users\\Camera\\Desktop\\GtHUb\\Two-Cameras\\Data\\AG052014-01\\21072014\\Trial5\\PS3_Vid83.avi"
cap = cv2.VideoCapture(load_video_filename)
ret, prvs = cap.read()
prvs = cv2.cvtColor(prvs, cv2.COLOR_BGR2GRAY)
frames = int(cap.get(cv.CV_CAP_PROP_FRAME_COUNT))
# Select mask in which we should look for the initial good points to track - a.k.a. select limb to track
pl.figure()
pl.title("Select mask")
pl.imshow(prvs, cmap=mpl_cm.Greys_r)
pts = []
while not len(pts):
pts = pl.ginput(0)
pl.close()
path = mpl_path.Path(pts)
mask = np.zeros(np.shape(prvs), dtype=np.uint8)
for ridx, row in enumerate(mask):
for cidx, pt in enumerate(row):
if path.contains_point([cidx, ridx]):
mask[ridx, cidx] = 1
for n in range(frames):
ret, next = cap.read()
next = cv2.cvtColor(next, cv2.COLOR_BGR2GRAY)
flow = cv2.calcOpticalFlowFarneback(prvs, next, 0.5, 3, 10, 3, 5, 1.2, 0)
distt = 3
threshold = 100
new_mask = np.zeros(np.shape(prvs), dtype=np.uint8)
for ridx, row in enumerate(mask):
for cidx, pt in enumerate(row):
if mask[ridx, cidx] == 1:
y = ridx + int(round(flow[ridx, cidx, 1]))
# print int(round(flow[ridx,cidx,1]))
x = cidx + int(round(flow[ridx, cidx, 0]))
if int(round(flow[ridx, cidx, 1])) < 10 and int(round(flow[ridx, cidx, 0])) < 10:
tmask = next[y - distt : y + distt + 1, x - distt : x + distt + 1]
# print tmask
idx = np.where(tmask > threshold)
# print idx[0]+y-distt
new_mask[idx[0] + y - distt, idx[1] + x - distt] = 1
mask = new_mask
next *= new_mask
cv2.imwrite("C:\\Users\\Camera\\Desktop\\TEST.png", next)
cv2.imshow("Limb", next)
k = cv2.waitKey(30) & 0xFF
if k == 27:
break
prvs = next
cv2.destroyAllWindows()
cap.release()
def _DeleteTraces_fired(self):
plt.figure()
plt.contourf(Data.wavelength, Data.time, Data.TrA_Data, 100)
plt.title('Pick between wavelength to delete (left to right)')
plt.xlabel('Wavelength')
plt.ylabel('Time')
fittingto = np.array(ginput(2))
plt.show()
plt.close()
index_wavelength_left=(np.abs(Data.wavelength-fittingto[0,0])).argmin()
index_wavelength_right=(np.abs(Data.wavelength-fittingto[1,0])).argmin()+1
if index_wavelength_right <= index_wavelength_left:
hold = index_wavelength_left
index_wavelength_left = index_wavelength_right
index_wavelength_right = hold
if index_wavelength_left == 0:
Data.TrA_Data = Data.TrA_Data[:,index_wavelength_right:]
Data.wavelength = Data.wavelength[index_wavelength_right:]
if index_wavelength_right == Data.wavelength.shape:
Data.TrA_Data = Data.TrA_Data[:,:index_wavelength_left]
Data.wavelength = Data.wavelength[:index_wavelength_left]
if index_wavelength_left != 0 & index_wavelength_right != Data.wavelength.shape:
Data.TrA_Data = np.hstack((Data.TrA_Data[:,:index_wavelength_left],Data.TrA_Data[:,index_wavelength_right:]))
Data.wavelength = np.hstack((Data.wavelength[:index_wavelength_left],Data.wavelength[index_wavelength_right:]))
self.log = "%s \nDeleted traces between %s and %s" %(self.log,fittingto[0,0],fittingto[1,0])
def fit_and_plot(self, image):
print "fit and plot"
p = self.parameters.IonsOnCamera
x_axis = np.arange(p.horizontal_min, p.horizontal_max + 1, self.image_region[0])
y_axis = np.arange(p.vertical_min, p.vertical_max + 1, self.image_region[1])
xx, yy = np.meshgrid(x_axis, y_axis)
#import IPython
#IPython.embed()
#self.fitter.report(params)
#ideally graphing should be done by saving to data vault and using the grapher
#p = Process(target = self.fitter.graph, args = (x_axis, y_axis, image, params, result))
#p.start()
pylab.imshow(image)
positions = pylab.ginput(0)
positions = [x + np.min(x_axis) for x,y in positions]
self.fitter = ion_state_detector(positions)
result, params = self.fitter.guess_parameters_and_fit(xx, yy, image)
self.fitter.graph(x_axis, y_axis, image, params, result)
position_list = []
try:
i = 0
while(True):
position_list.append(params['pos'+str(i)].value)
i += 1
except KeyError:
pass
self.pv.set_parameter('IonsOnCamera','fit_background_level', params['background_level'].value)
self.pv.set_parameter('IonsOnCamera','fit_amplitude', params['amplitude'].value)
self.pv.set_parameter('IonsOnCamera','ion_positions', position_list) #TODO ?? FIXME
self.pv.set_parameter('IonsOnCamera','ion_number', len(position_list)) #TODO ?? FIXME
self.pv.set_parameter('IonsOnCamera','fit_sigma', params['sigma'].value)
def get_terminus():
from matplotlib.widgets import Cursor
def tellme(s):
print s
plt.title(s,fontsize=16)
plt.draw()
plt.setp(plt.gca(),autoscale_on=False)
cursor = Cursor(plt.axes(), useblit=True, color='white', linewidth=1 )
happy = False
while not happy:
pts = []
while len(pts) < 4:
tellme('Select 4 corners of the terminus region')
pts = np.asarray( plt.ginput(4, timeout=-1) )
if len(pts) < 4:
tellme('Too few points, starting over')
time.sleep(1) # Wait a second
ph = plt.fill(pts[:,0], pts[:,1], 'white', lw = 2, alpha=0.5)
tellme('Done? Press any key if yes, mouse click to reset')
happy = plt.waitforbuttonpress()
# Get rid of fill
if not happy:
for p in ph: p.remove()
return pts
def get_wavelimits(self, qrspeaks, leads=range(12)):
"""
Given qrspeaks / point on qrs,
interactively, obtain qrs onset, end and tend
leads is a list of the indices of ECG leads
"""
ax = pylab.subplot(111)
ax.set_title("Pick QRS onset, end and T end")
#ax = matplotlib.pyplot.axes()
meanrr = int(scipy.mean(qrspeaks[1:] - qrspeaks[:-1]))
onems = int(self.samplingrate / 1000)
r = qrspeaks[int(len(qrspeaks) * 2/3)] # choose a beat 2/3 of way
start = r - 200 * onems # 400 ms before
end = start + meanrr
for l in leads:
ax.plot(self.data[start:end, l])
cursor = Cursor(ax)
pts = pylab.ginput(3)
q, s, t = [pt[0] for pt in pts]
#pylab.show()
qrsonsets = qrspeaks + int(q - 200 * onems)
qrsends = qrspeaks + int(s - 200 * onems)
tends = qrspeaks + int(t - 200 * onems)
return qrsonsets, qrsends, tends
def fit_and_plot(self, image):
print "fit and plot"
p = self.parameters.IonsOnCamera
x_axis = np.arange(p.horizontal_min, p.horizontal_max + 1, self.image_region[0])
y_axis = np.arange(p.vertical_min, p.vertical_max + 1, self.image_region[1])
xx, yy = np.meshgrid(x_axis, y_axis)
#import IPython
#IPython.embed()
#self.fitter.report(params)
#ideally graphing should be done by saving to data vault and using the grapher
#p = Process(target = self.fitter.graph, args = (x_axis, y_axis, image, params, result))
#p.start()
pylab.figure()
pylab.imshow(image)
pylab.show()
pylab.figure()
img_1d = np.sum(image, axis=0)
pylab.plot(img_1d)
threshold = pylab.ginput(0)
threshold = threshold[0][1]
print threshold
ion_edges = self.isolate_ions(img_1d, threshold)
centers = self.fit_individual_ions(img_1d, ion_edges)
deltax = []
for i, x in enumerate(ion_edges):
try: deltax.append( centers[i+1] - centers[i] )
except: pass
pylab.figure()
pylab.plot(deltax, 'o')
pylab.show()
def getCoordinate(direction='both',axh=None,fig=None):
"""Tool for selecting a coordinate, functionality similar to ginput for a single point. Finish with right mouse button."""
if not axh:
axh = pl.gca()
if not fig: fig = pl.gcf()
hor=False;ver=False
if direction is 'horizontal' or 'hor' or 'both':
hor=True
if direction is 'vertical' or 'ver' or 'both':
ver=True
finished=False
def button_press_callback(event):
if event.inaxes:
if event.button == 3:
finished = True
fig.canvas.mpl_connect('button_press_event', button_press_callback)
print("Select a coordinate, finish with right click.")
linh = []
while not finished:
for tlinh in linh:
tlinh.remove()
linh = []
pl.draw()
pos = pl.ginput(1)[0]
if hor:
linh.append(pl.axvline(pos[0]))
if ver:
linh.append(pl.axhline(pos[1]))
pl.draw()
pl.waitforbuttonpress()
fig.canvas.draw()
return pos
def Set_Masks(Filename,number,message,save_name): Video = cv2.VideoCapture(Filename) height = int(Video.get(4)) width = int(Video.get(3)) frames = int(Video.get(cv.CV_CAP_PROP_FRAME_COUNT)) FOURCC = cv2.cv.CV_FOURCC(*'XVID') color_names_RBG = [(255,0,0),(0,255,0),(0,0,255),(255,255,0),(255,0,255),(0,255,255),(0,0,0)] #BGR s,frame = Video.read() disp_frame = frame[:] frame = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) Masks = np.zeros((number,height,width),dtype=np.uint8) for n in range(number): pl.figure() pl.title(message+" %i"%(n+1)) pl.imshow(disp_frame, cmap=mpl_cm.Greys_r) pts = [] while not len(pts): pts = pl.ginput(0) pts = np.array(pts, dtype=np.int32) pl.close() path = mpl_path.Path(pts) for ridx,row in enumerate(frame): for cidx,pt in enumerate(row): if path.contains_point([cidx, ridx]): Masks[n,ridx,cidx] = 1 cv2.polylines(disp_frame, [pts], 1, color_names_RBG[n%6], thickness=1) #BGR cv2.imwrite(save_name,disp_frame) Video.release() return Masks
def ctc_align_targets(outputs,targets,threshold=100.0,verbose=0,debug=0,lo=1e-5):
"""Perform alignment between the `outputs` of a neural network
classifier and some targets. The targets themselves are a time sequence
of vectors, usually a unary representation of each target class (but
possibly sequences of arbitrary posterior probability distributions
represented as vectors)."""
outputs = maximum(lo,outputs)
outputs = outputs * 1.0/sum(outputs,axis=1)[:,newaxis]
# first, we compute the match between the outputs and the targets
# and put the result in the log domain
match = dot(outputs,targets.T)
lmatch = log(match)
if debug:
figure("ctcalign"); clf();
subplot(411); imshow(outputs.T,interpolation='nearest',cmap=cm.hot)
subplot(412); imshow(lmatch.T,interpolation='nearest',cmap=cm.hot)
assert not isnan(lmatch).any()
# Now, we compute a forward-backward algorithm over the matches between
# the input and the output states.
both = forwardbackward(lmatch)
# We need posterior probabilities for the states, so we need to normalize
# the output. Instead of keeping track of the normalization
# factors, we just normalize the posterior distribution directly.
epath = exp(both-amax(both))
l = sum(epath,axis=0)[newaxis,:]
epath /= where(l==0.0,1e-9,l)
# The previous computation gives us an alignment between input time
# and output sequence position as posteriors over states.
# However, we actually want the posterior probability distribution over
# output classes at each time step. This dot product gives
# us that result. We renormalize again afterwards.
aligned = maximum(lo,dot(epath,targets))
l = sum(aligned,axis=1)[:,newaxis]
aligned /= where(l==0.0,1e-9,l)
if debug:
subplot(413); imshow(epath.T,cmap=cm.hot,interpolation='nearest')
subplot(414); imshow(aligned.T,cmap=cm.hot,interpolation='nearest')
ginput(1,0.01);
return aligned
def set_parameter(self, name, value):
"""
This functions sets a parameter named "name" to a value.
"""
try:
# if we enter something like "min=x", get a click from the user
if value in ['x','y']:
# get the click
print "Please click somewhere to get the "+value+" value."
_st.raise_figure_window()
click = _pylab.ginput()
# use the click value.
if len(click)>0 and value=='x': value = click[0][0]
elif len(click)>0 and value=='y': value = click[0][1]
else:
print "\nCLICK ABORTED.\n"
return
elif value in ['dx', 'dy', 'slope']:
# get two clicks
print "Please click twice to use the "+value+" value."
_st.raise_figure_window()
clicks = _pylab.ginput(2)
# make sure we got two clicks
if len(clicks) == 2:
dx = clicks[1][0]-clicks[0][0]
dy = clicks[1][1]-clicks[0][1]
if value=='dx': value = dx
if value=='dy': value = dy
if value=='slope': value = dy/dx
else:
print "\nCLICKS ABORTED.\n"
return
i = self.pnames.index(name)
self.p0[i] = float(value)
return True
except:
print "ERROR:", name, "is not a valid variable or", value, "is not a valid value."
return False
def on_key(event):
#print 'you pressed', event.key, event.xdata, event.ydata
if (event.key == 'q'):
sys.exit(0)
#
elif (event.key == 'w'):
pylab.close(event.canvas.figure)
#
elif (event.key == 'd'):
print "##############################################################"
print "Please click two points to get the distance and slope."
from matplotlib.widgets import Cursor
cursor = Cursor(event.inaxes, useblit=False, color='red', linewidth=1)
points = pylab.ginput(n=2, show_clicks=True, timeout=0)
xs = pylab.array([points[0][0], points[1][0]])
ys = pylab.array([points[0][1], points[1][1]])
dx = xs[1] - xs[0]
dy = ys[1] - ys[0]
dy_log = pylab.log10(ys[0]) - pylab.log10(ys[1])
dy_ln = pylab.log(ys[0]) - pylab.log(ys[1])
angle = pylab.arctan2(dy, dx)
print "points = ", points
print "distance (x) =", dx
print "distance (y) =", dy
print "distance =", pylab.sqrt( dx**2 + dy**2 )
print "Ratio: x0/x1 =", xs[0] / xs[1], " x1/x0 =", xs[1] / xs[0], " y0/y1 =", ys[0] / ys[1], " y1/y0 =", ys[1] / ys[0]
print "dy/y0 = ", dy/ys[0]
print "dx/x0 = ", dx/xs[0]
print "Angle: theta = atan2(y/x) =", angle, "rad =", angle*180.0/pylab.pi, "deg"
print "Slope: ", dy/dx, " 1/slope =", dx/dy
print "Slope (log10 scale):", dy_log/dx
print "Slope (ln scale):", dy_ln/dx
event.inaxes.plot([points[0][0], points[1][0]], [points[0][1], points[1][1]], '--r', lw=1.0)
event.inaxes.plot([points[0][0], points[1][0]], [points[0][1], points[1][1]], '+r', lw=1.0)
pylab.draw()
#
elif (event.key == 'a'):
print "##############################################################"
print "Please click a point to get the position."
from matplotlib.widgets import Cursor
cursor = Cursor(event.inaxes, useblit=False, color='red', linewidth=1)
point = pylab.ginput(n=1, show_clicks=False, timeout=0)
print "point = ", point
event.inaxes.plot(point[0][0], point[0][1], '+r', lw=1.0)
pylab.draw()
def main(argv):
# filename = image file
filename = os.path.realpath(argv[1])
print filename
c=mpimg.imread(filename)
fig=plt.imshow(c)
plt.draw()
# the next values should be input for the specific chart
# use the new opened sketch to decide what they should be
minX=float(input('minX: '))
maxX=float(input('maxX: '))
minY=float(input('minY: '))
maxY=float(input('maxY: '))
data = np.asarray(ginput(n=-5,show_clicks=True, timeout=-5))
X,Y = data[:,0],data[:,1]
x = []; y = []
for a,b in zip(X,Y):
x.append(a)
y.append(b)
# first point: min x
# second point: max x
# third point: min y
# fourth point: max y
# next points - the graph itself.
TetaX=np.arctan2((y[1]-y[0]),(x[1]-x[0]))
CosX=np.cos(TetaX)
SinX=np.sin(TetaX)
SinTeta=SinX
CosTeta=CosX
xOut = x[0:len(x)]
yOut = y[0:len(y)]
for i,(xx,yy) in enumerate(zip(x,y)):
xOut[i] = xx*CosTeta-yy*SinTeta
yOut[i] = xx*SinTeta+yy*CosTeta
xOut0, xOut1 = xOut[0], xOut[1]
yOut2, yOut3 = yOut[2], yOut[3]
xo = (xOut-xOut0)/(xOut1-xOut0)*(maxX-minX)+minX
yo = (yOut-yOut2)/(yOut3-yOut2)*(maxY-minY)+minY
xOut = xo[4:len(xo)]
yOut = yo[4:len(yo)]
g = np.column_stack((xOut,yOut))
f = open('temp.csv','wb')
csvWriter = csv.writer(f, delimiter=' ')
csvWriter.writerows(g)
f.close()
print xOut
print yOut
def addgrain(self,ori=0):
'''
add a grain inside the microstructure
:param ori: orienation of the new grain [phi1 phi] (default random value)
:type ori: array, float
:return: new_micro, object with the new grain include
:rtype: aita
:Exemple:
>>> data.addgrain()
'''
# select the contour of the grains
h=self.grains.plot()
# click on the submit of the new grain
plt.waitforbuttonpress()
print('click on the submit of the new grain :')
x=np.array(pylab.ginput(3))/self.grains.res
plt.close('all')
# select a subarea contening the triangle
minx=np.int(np.fix(np.min(x[:,0])))
maxx=np.int(np.ceil(np.max(x[:,0])))
miny=np.int(np.fix(np.min(x[:,1])))
maxy=np.int(np.ceil(np.max(x[:,1])))
# write all point inside this area
gpoint=[]
for i in list(range(minx,maxx)):
for j in list(range(miny,maxy)):
gpoint.append([i,j])
# test if the point is inside the triangle
gIn=[]
for i in list(range(len(gpoint))):
gIn.append(isInsideTriangle(gpoint[i],x[0,:],x[1,:],x[2,:]))
gpointIn=np.array(gpoint)[np.array(gIn)]
#transform in xIn and yIn, the coordinate of the map
xIn=np.shape(self.grains.field)[0]-gpointIn[:,1]
yIn=gpointIn[:,0]
# add one grains
self.grains.field[xIn,yIn]=np.nanmax(self.grains.field)+1
# add the orientation of the grains
if ori==0:
self.phi1.field[xIn,yIn]=random.random()*2*math.pi
self.phi.field[xIn,yIn]=random.random()*math.pi/2
else:
self.phi1.field[xIn,yIn]=ori[0]
self.phi.field[xIn,yIn]=ori[1]
returnphi=self.phi1*mask
def load_pts(self, mode='auto'):
try:
self.man_update(np.load(self.fh.make_path('pts.npz', mode=self.fh.BL)))
except:
if mode == 'auto':
self.all_possible_pts = []
invalid = True
attempts = 0
while invalid:
if attempts > 500:
raise Exception('Pts cannot be found.')
img = self.background_image.copy()
lp_ksizes = [13,15,17,19,21,23,25] #from 5-15 before
lp_ksize = rand.choice(lp_ksizes)
sbd_areas = [range(3,20), range(61,140)] #8,26 46,55
sbd_area = [rand.choice(sbd_areas[0]), rand.choice(sbd_areas[1])]
sbd_circs = [np.arange(0.05,0.35), range(1000,1001)]#0.19,0.35 1000
sbd_circ = [rand.choice(sbd_circs[0]), rand.choice(sbd_circs[1])]
subtr_rowmeans = rand.choice([True,False])
if subtr_rowmeans:
img = img-np.mean(img,axis=1)[:,None]
img = cv2.Laplacian(img, cv2.CV_32F, ksize=lp_ksize)
img += abs(img.min())
img = img/img.max() *255
img = img.astype(np.uint8)
#pl.figure(1);pl.imshow(img,cmap=pl.cm.Greys_r)
params = cv2.SimpleBlobDetector_Params()
params.filterByArea = True
params.filterByCircularity = True
params.minArea,params.maxArea = sbd_area
params.minCircularity,params.maxCircularity = sbd_circ
detector = cv2.SimpleBlobDetector(params)
fs = detector.detect(img)
pts = np.array([f.pt for f in fs])
pts = np.round(pts).astype(np.uint32)
x = img.copy()
for pt in pts:
cv2.circle(x, tuple(pt), 4, (255,255,255), thickness=3)
#pl.figure(2);pl.imshow(x);raw_input()
self.pts = pts
invalid = not self.verify_pts()
attempts += 1
elif mode == 'manual':
pl.imshow(self.background_image, cmap=pl.cm.Greys_r)
pl.title('center3->middle6->outer6')
pts = pl.ginput(n=15, timeout=-1)
pts = np.round(pts).astype(np.uint32)
self.pts = np.array(pts)
pl.close()
# note that verify is being skipped
self.c3i,self.m6i,self.o6i = np.arange(0,3),np.arange(3,9),np.arange(9,15)
self.pts_c = np.mean(self.pts, axis=0)
self.classify_pts()
def createWireMask(self,data=None):
if data==None:
import ixppy
d = ixppy.dataset('/reg/g/xpp/data/example_data/cspad/liquid_scattering/hdf5/xpp43512-r0004.h5',['cspad'])
data = d.cspad.rdStepData(0,range(10))
i = np.mean(data,axis=0)
ib = self.bin(i)
tools.imagesc(self.xVec,self.yVec,ib)
tools.clim_std()
pl.draw()
print "Roughly select wire end pairs, press middle mouse button when finished."
wires = []
tpos = np.array(pl.ginput(2))
pointno = 0
while not tpos==[]:
tpos = np.array(tpos)
pl.plot(tpos[:,0],tpos[:,1],'go-')
for pno in range(2):pl.text(tpos[pno,0],tpos[pno,1],str(pointno),color='r')
wires.append(tpos)
pointno += 1
tpos = pl.ginput(2)
refwires = []
for pos in wires:
refwires.append(self._refinePoints(pos,ib))
wirewidths = []
print refwires
for refwire in refwires:
trad = self._getOneWire(refwire,i,rmax=1000)
wirewidths.append(trad)
masked = np.zeros(np.shape(i),dtype=bool)
ax = self.xpx
ay = self.ypx
for refwire,wirewidth in zip(refwires,wirewidths):
points = refwire
m = np.diff(points[:,1])/np.diff(points[:,0])
c = points[0,1] - points[0,0]*m
m_ = -1/m
dist_perp = (ay-m*ax-c)/np.sqrt(m**2+1)
dist_par = (ay-m_*ax)/np.sqrt(m_**2+1)
masked[np.abs(dist_perp)<wirewidth] = True
np.save('cspad_last_pixel_mask.npy',masked)
def demo_interactive():
"""
Interactive label
"""
im = np.array(Image.open('./computer_vision/scenery.jpg'))
pl.imshow(im)
print('Please click 3 points')
"""Get mouse click input from GUI"""
x = pl.ginput(3)
print("You've clicked:",x)
pl.show()
def add_straight_tunnel(tunnels,tunnel_oris,horiz,this_name,parent_name=None,update_plot=1,**kwargs): ''' specify start and end of straight line. if parent_name is None, treat as hillside if update_plot, draws all tunnels in figure specified (e.g. update_plot == 1; plot in figure 1) ''' print >> sys.stderr, 'click start and end' tunnels[this_name] = pylab.ginput(2,0) if parent_name is not None: tunnel_oris[this_name] = parent_name if update_plot: plot_tunnels(tunnels,horiz,update_plot)
def extract_pop(histo, nbr_pic, width) :
result = []
X = ginput(nbr_pic)
size_hist = size(histo[1])
Xmin = histo[1][0]
Xmax = histo[1][-1]
step = 1.0 * abs(Xmax-Xmin)/size_hist
for i in range(nbr_pic) :
center = floor(abs(X[i][0] - Xmin)/step)
result.append(sum(histo[0][center-width:center+width]))
return [result, 1.0*array(result) / sum(result)]
#注意 返回的是绝对路径
return [
os.path.join(path, f) for f in os.listdir(path) if f.endswith('.jpg')
]
import pylab as plb
import PIL.Image as Image
#循环读图
for path in getAllImages(r'C:\Users\wentao99\Desktop\11111'):
#读图
img = Image.open(path)
#显示
plb.imshow(img)
#设置裁剪点（4个）
corner = plb.ginput(4)
#顺时针取点求解
left = (corner[0][0] + corner[3][0]) / 2
top = (corner[1][1] + corner[0][1]) / 2
reight = (corner[1][0] + corner[2][0]) / 2
under = (corner[3][1] + corner[2][1]) / 2
#print left,top,reight,under
#box = [left,top,reight,under]
#box中的数必须是 int 否则会报错
box = [int(left), int(top), int(reight), int(under)]
#裁剪
img2 = img.crop(box)
#显示裁剪后的效果
#plb.imshow(img2)
#plb.show()
#储存为原来路径覆盖原文件
def coo_max(files, psfName, manual=True):
py.close(1)
py.figure(1, figsize=(10, 10))
py.subplots_adjust(left=0.1, bottom=0.08, right=0.95, top=0.93)
firstFramePos = None
for _file in files:
fileDir, fileName = os.path.split(_file)
fileRoot, fileExt = os.path.splitext(fileName)
# Make a max file
_max = open(fileDir + fileRoot + '.max', 'w')
_max.write('35000\n')
_max.close()
# Read in the image for display to select a coo star
img, hdr = pyfits.getdata(_file, header=True)
imgRescale = img_scale.sqrt(img, scale_min=400, scale_max=5000)
fig = py.figure(1)
foo = fig.gca().get_xlabel()
if foo != '':
psfName = foo
print 'Getting from old plot:', psfName
py.clf()
py.imshow(imgRescale, aspect='equal', cmap=py.cm.gray)
py.title('{0} PA={1:.0f}'.format(fileRoot, hdr['PA']))
fig.gca().set_xlabel('{0}'.format(psfName))
print 'Plotting: ', psfName
py.ylabel('Press "p" for new star name.')
fig.canvas.mpl_connect('key_press_event', key_press)
starFound = False
while not starFound:
psfName = fig.gca().get_xlabel()
print 'In while: ', psfName
# Get the user selected PSF stars
if firstFramePos == None or manual == True:
pts = py.ginput(1, timeout=0)
xinit = int(round(pts[0][0]))
yinit = int(round(pts[0][1]))
else:
xinit = firstFramePos[0]
yinit = firstFramePos[1]
boxSize = 50
# Get an initial sub-image
imgSub, xLo, yLo = get_sub_image(img, boxSize, xinit, yinit)
# Find the maximum pixel value within this box...
# assume this is the star and re-center up on it
maxIdx = np.where(imgSub == imgSub.max())
xinit = xLo + maxIdx[1][0]
yinit = yLo + maxIdx[0][0]
# Get an sub-image centered on brightest pixel
imgSub, xLo, yLo = get_sub_image(img, boxSize, xinit, yinit)
yc, xc = scipy.ndimage.center_of_mass(imgSub)
xc += xLo
yc += yLo
print '%s Centroid: x=%.2f y=%.2f' % (fileRoot, xc, yc)
py.figure(2)
py.clf()
py.imshow(imgRescale, aspect='equal', cmap=py.cm.gray)
py.plot([xc], [yc], 'kx', ms=10)
py.xlim(xc - 30, xc + 30)
py.ylim(yc - 30, yc + 30)
py.figure(1)
gaussInfo = psf.moments(imgSub, SubSize=5)
g_height = gaussInfo[0]
g_muX = gaussInfo[1]
g_muY = gaussInfo[2]
g_FWHMX = gaussInfo[3]
g_FWHMY = gaussInfo[4]
g_FWHM = gaussInfo[5]
g_Ellip = gaussInfo[6]
g_angle = gaussInfo[7]
hdrout = '{0:5s} {1:5s} {2:5s} {3:5s} {4:5s} '
hdrout += '{5:5s} {6:4s} {7}\n'
strout = '{0:5.2f} {1:5.2f} {2:5.2f} {3:5.2f} {4:5.2f} '
strout += '{5:5.2f} {6:4.2f} {7:.1f}\n'
_gauss = open(fileDir + fileRoot + '.metrics', 'w')
_gauss.write(
hdrout.format('muX', 'muY', 'FWHMX', 'FWHMY', 'FWHM', 'Ellip',
'Angle', 'Height'))
_gauss.write(
strout.format(g_muX, g_muY, g_FWHMX, g_FWHMY, g_FWHM, g_Ellip,
g_angle, g_height))
_gauss.close()
# Make a max file
_coo = open(fileDir + fileRoot + '.coo', 'w')
_coo.write('{0:.2f} {1:.2f} {2}\n'.format(xc, yc, psfName))
_coo.close()
if firstFramePos == None:
firstFramePos = [xc, yc]
starFound = True
return
def _process_segment(self, page_image, page, page_xywh, page_id,
input_file, n):
LOG = getLogger('OcrdAnybaseocrBinarizer')
raw = ocrolib.pil2array(page_image)
if len(raw.shape) > 2:
raw = np.mean(raw, 2)
raw = raw.astype("float64")
# perform image normalization
image = raw - amin(raw)
if amax(image) == amin(image):
LOG.info("# image is empty: %s" % (page_id))
return
image /= amax(image)
# check whether the image is already effectively binarized
if self.parameter['gray']:
extreme = 0
else:
extreme = (np.sum(image < 0.05) +
np.sum(image > 0.95)) * 1.0 / np.prod(image.shape)
if extreme > 0.95:
comment = "no-normalization"
flat = image
else:
comment = ""
# if not, we need to flatten it by estimating the local whitelevel
LOG.info("Flattening")
m = interpolation.zoom(image, self.parameter['zoom'])
m = filters.percentile_filter(m,
self.parameter['perc'],
size=(self.parameter['range'], 2))
m = filters.percentile_filter(m,
self.parameter['perc'],
size=(2, self.parameter['range']))
m = interpolation.zoom(m, 1.0 / self.parameter['zoom'])
if self.parameter['debug'] > 0:
clf()
imshow(m, vmin=0, vmax=1)
ginput(1, self.parameter['debug'])
w, h = minimum(array(image.shape), array(m.shape))
flat = clip(image[:w, :h] - m[:w, :h] + 1, 0, 1)
if self.parameter['debug'] > 0:
clf()
imshow(flat, vmin=0, vmax=1)
ginput(1, self.parameter['debug'])
# estimate low and high thresholds
LOG.info("Estimating Thresholds")
d0, d1 = flat.shape
o0, o1 = int(self.parameter['bignore'] * d0), int(
self.parameter['bignore'] * d1)
est = flat[o0:d0 - o0, o1:d1 - o1]
if self.parameter['escale'] > 0:
# by default, we use only regions that contain
# significant variance; this makes the percentile
# based low and high estimates more reliable
e = self.parameter['escale']
v = est - filters.gaussian_filter(est, e * 20.0)
v = filters.gaussian_filter(v**2, e * 20.0)**0.5
v = (v > 0.3 * amax(v))
v = morphology.binary_dilation(v, structure=ones((int(e * 50), 1)))
v = morphology.binary_dilation(v, structure=ones((1, int(e * 50))))
if self.parameter['debug'] > 0:
imshow(v)
ginput(1, self.parameter['debug'])
est = est[v]
lo = stats.scoreatpercentile(est.ravel(), self.parameter['lo'])
hi = stats.scoreatpercentile(est.ravel(), self.parameter['hi'])
# rescale the image to get the gray scale image
LOG.info("Rescaling")
flat -= lo
flat /= (hi - lo)
flat = clip(flat, 0, 1)
if self.parameter['debug'] > 0:
imshow(flat, vmin=0, vmax=1)
ginput(1, self.parameter['debug'])
binarized = 1 * (flat > self.parameter['threshold'])
# output the normalized grayscale and the thresholded images
# print_info("%s lo-hi (%.2f %.2f) angle %4.1f %s" % (fname, lo, hi, angle, comment))
LOG.info("%s lo-hi (%.2f %.2f) %s" % (page_id, lo, hi, comment))
LOG.info("writing")
if self.parameter['debug'] > 0 or self.parameter['show']:
clf()
gray()
imshow(binarized)
ginput(1, max(0.1, self.parameter['debug']))
page_xywh['features'] += ',binarized'
bin_array = array(255 * (binarized > ocrolib.midrange(binarized)), 'B')
bin_image = ocrolib.array2pil(bin_array)
file_id = make_file_id(input_file, self.output_file_grp)
file_path = self.workspace.save_image_file(
bin_image,
file_id + '-IMG',
page_id=page_id,
file_grp=self.output_file_grp)
page.add_AlternativeImage(
AlternativeImageType(filename=file_path,
comments=page_xywh['features']))
def process(self):
for (n, input_file) in enumerate(self.input_files):
pcgts = page_from_file(self.workspace.download_file(input_file))
fname = pcgts.get_Page().imageFilename
img = self.workspace.resolve_image_as_pil(fname)
param = self.parameter
base, _ = ocrolib.allsplitext(fname)
#basefile = ocrolib.allsplitext(os.path.basename(fpath))[0]
if param['parallel'] < 2:
print_info("=== %s " % (fname))
raw = ocrolib.read_image_gray(img.filename)
flat = raw
#flat = np.array(binImg)
# estimate skew angle and rotate
if param['maxskew'] > 0:
if param['parallel'] < 2:
print_info("estimating skew angle")
d0, d1 = flat.shape
o0, o1 = int(param['bignore'] * d0), int(param['bignore'] * d1)
flat = amax(flat) - flat
flat -= amin(flat)
est = flat[o0:d0 - o0, o1:d1 - o1]
ma = param['maxskew']
ms = int(2 * param['maxskew'] * param['skewsteps'])
angle = self.estimate_skew_angle(est,
linspace(-ma, ma, ms + 1))
flat = interpolation.rotate(flat,
angle,
mode='constant',
reshape=0)
flat = amax(flat) - flat
else:
angle = 0
# self.write_angles_to_pageXML(base,angle)
# estimate low and high thresholds
if param['parallel'] < 2:
print_info("estimating thresholds")
d0, d1 = flat.shape
o0, o1 = int(param['bignore'] * d0), int(param['bignore'] * d1)
est = flat[o0:d0 - o0, o1:d1 - o1]
if param['escale'] > 0:
# by default, we use only regions that contain
# significant variance; this makes the percentile
# based low and high estimates more reliable
e = param['escale']
v = est - filters.gaussian_filter(est, e * 20.0)
v = filters.gaussian_filter(v**2, e * 20.0)**0.5
v = (v > 0.3 * amax(v))
v = morphology.binary_dilation(v,
structure=ones(
(int(e * 50), 1)))
v = morphology.binary_dilation(v,
structure=ones(
(1, int(e * 50))))
if param['debug'] > 0:
imshow(v)
ginput(1, param['debug'])
est = est[v]
lo = stats.scoreatpercentile(est.ravel(), param['lo'])
hi = stats.scoreatpercentile(est.ravel(), param['hi'])
# rescale the image to get the gray scale image
if param['parallel'] < 2:
print_info("rescaling")
flat -= lo
flat /= (hi - lo)
flat = clip(flat, 0, 1)
if param['debug'] > 0:
imshow(flat, vmin=0, vmax=1)
ginput(1, param['debug'])
deskewed = 1 * (flat > param['threshold'])
# output the normalized grayscale and the thresholded images
print_info("%s lo-hi (%.2f %.2f) angle %4.1f" %
(pcgts.get_Page().imageFilename, lo, hi, angle))
if param['parallel'] < 2:
print_info("writing")
ocrolib.write_image_binary(base + ".ds.png", deskewed)
orientation = TextRegionType(orientation=angle)
pcgts.get_Page().add_TextRegion(orientation)
ID = concat_padded(self.output_file_grp, n)
self.workspace.add_file(ID=ID,
file_grp=self.output_file_grp,
pageId=input_file.pageId,
mimetype="image/png",
url=base + ".ds.png",
local_filename='%s/%s' %
(self.output_file_grp, ID),
content=to_xml(pcgts).encode('utf-8'))
def completeness(self, catalogue, config, saveplot=False, filetype='png',
timeout=120):
'''
:param catalogue:
Earthquake catalogue as instance of
:class: hmtk.seismicity.catalogue.Catalogue
:param dict config:
Configuration parameters of the algorithm, containing the
following information -
'magnitude_bin' Size of magnitude bin (non-negative float)
'time_bin' Size (in dec. years) of the time window
(non-negative float)
'increment_lock' Boolean to indicate whether to ensure
completeness magnitudes always decrease with more
recent bins
:returns:
2-column table indicating year of completeness and corresponding
magnitude numpy.ndarray
'''
if saveplot and not isinstance(saveplot, str):
raise ValueError('To save the figures enter a filename: ')
# Get magntitude bins
magnitude_bins = self._get_magnitudes_from_spacing(
catalogue.data['magnitude'],
config['magnitude_bin'])
dec_time = catalogue.get_decimal_time()
completeness_table = np.zeros([len(magnitude_bins) - 1, 2],
dtype=float)
min_year = float(np.min(catalogue.data['year']))
max_year = float(np.max(catalogue.data['year'])) + 1.0
has_completeness = np.zeros(len(magnitude_bins) - 1, dtype=bool)
for iloc in range(0, len(magnitude_bins) - 1):
lower_mag = magnitude_bins[iloc]
upper_mag = magnitude_bins[iloc + 1]
idx = np.logical_and(catalogue.data['magnitude'] >= lower_mag,
catalogue.data['magnitude'] < upper_mag)
cumvals = np.cumsum(np.ones(np.sum(idx)))
plt.plot(dec_time[idx], cumvals, '.')
plt.xlim(min_year, max_year + 5)
title_string = 'Magnitude %5.2f to %5.2f' % (lower_mag, upper_mag)
plt.title(title_string)
pts = pylab.ginput(1, timeout=timeout)[0]
if pts[0] <= max_year:
# Magnitude bin has no completeness!
has_completeness[iloc] = True
completeness_table[iloc, 0] = np.floor(pts[0])
completeness_table[iloc, 1] = magnitude_bins[iloc]
print completeness_table[iloc, :], has_completeness[iloc]
if config['increment_lock'] and (iloc > 0) and \
(completeness_table[iloc, 0] > completeness_table[iloc - 1, 0]):
completeness_table[iloc, 0] = \
completeness_table[iloc - 1, 0]
# Add marker line to indicate completeness point
marker_line = np.array([
[0., completeness_table[iloc, 0]],
[cumvals[-1], completeness_table[iloc, 0]]])
plt.plot(marker_line[:, 0], marker_line[:, 1], 'r-')
if saveplot:
filename = saveplot + '_' + ('%5.2f' % lower_mag) + ('%5.2f'
% upper_mag) + '.' + filetype
plt.savefig(filename, format=filetype)
plt.close()
return completeness_table[has_completeness, :]
def multi_point_warp(dest_im):
source_im = np.array(Image.open('images/opencv.jpg'), dtype=np.uint8)
plt.figure(1)
plt.imshow(source_im)
plt.show()
print("Click source and destination of warp point")
p = np.asarray(plt.ginput(n=2, mouse_stop=2), dtype=np.float32)
print(p)
if (p.size == 0):
#cv2.imshow('image',dest_im)
return dest_im, False
print(p[0] - p[1])
plt.plot(p[:, 0], p[:, 1], color="blue")
plt.plot(p[0][0], p[0][1], marker='x', markersize=3, color="red")
plt.plot(p[1][0], p[1][1], marker='x', markersize=3, color="red")
#plt.show()
start = time.time()
#Generate pixels coordinates in the destination image
dest_im = np.zeros(source_im.shape, dtype=np.uint8)
max_row = source_im.shape[0] - 1
max_col = source_im.shape[1] - 1
dest_rows = dest_im.shape[0]
dest_cols = dest_im.shape[1]
#Painting outline of source image black, so out of bounds pixels can be painted black
source_im[0] = 0
source_im[max_row] = 0
source_im[:, 0] = 0
source_im[:, max_col] = 0
#Generate pixel coordinates in the destination image
ind = np.arange(dest_rows * dest_cols)
row_vect = ind // dest_cols
col_vect = ind % dest_cols
coords = np.vstack((row_vect, col_vect))
#Computing pixel weights, pixels close to p[1] will have higher weights
dist = np.sqrt(
np.square(p[1][1] - row_vect) + np.square(p[1][0] - col_vect))
weight = np.exp(-dist /
100) #Constant needs to be tweaked depending on image size
#Computing pixel weights, pixels close to p[1] will have higher weights
source_coords = np.zeros(coords.shape, dtype=np.int)
disp_r = (weight * (p[0][1] - p[1][1])).astype(int)
disp_c = (weight * (p[0][0] - p[1][0])).astype(int)
source_coords[0] = coords[0] + disp_r
source_coords[1] = coords[1] + disp_c
#Fixing out-of-bounds coordinates
source_coords[source_coords < 0] = 0
source_coords[0, source_coords[0] > max_row] = max_row
source_coords[1, source_coords[1] > max_col] = max_col
dest_im = source_im[source_coords[0],
source_coords[1], :].reshape(dest_rows, dest_cols, 3)
# cv2.imshow('image',dest_im)
elapsed_time = time.time() - start
print('Elapsed time: {0:.2f} '.format(elapsed_time))
return dest_im, True
def _lss_corr(obs,
interactive=True,
maxcr=False,
figno=20,
rawxy=None,
target='target',
chatter=0):
'''determine the LSS correction for the readout streak source '''
import os
import numpy as np
try:
from astropy.io import fits
except:
import pyfits as fits
from pylab import figure,imshow,ginput,axvspan,\
axhspan,plot,autumn,title,clf
file = obs['infile']
ext = obs['extension']
cols = obs['streak_col_SN_CR_ERR']
kol = []
countrates = []
circle = [
np.sin(np.arange(0, 2 * np.pi, 0.05)),
np.cos(np.arange(0, 2 * np.pi, 0.05))
]
for k in cols:
kol.append(k[1]) # S/N
countrates.append(k[2])
kol = np.array(kol)
if len(kol) == 0:
print("zero array kol in _lss_corr ???!!!!")
print("LSS correction cannot be determined.")
return 1.0, (0, 0), (1100.5, 1100.5)
k_sn_max = np.where(np.max(kol) == kol) # maximum s/n column
print("k S/N max=", k_sn_max[0][0])
kol = []
for k in cols:
kol.append(k[0]) # column number relative to bottom rh corner subimage
if len(kol) == 0:
print("LSS correction cannot be determined.")
return 1.0, (0, 0), (1100.5, 1100.5)
im = fits.getdata(file, ext=ext)
hdr = fits.getheader(file, ext=ext)
#binx = hdr['binx']
mn = im.mean()
sig = im.std()
# plot
figure(figno)
clf()
autumn()
imshow(im, vmin=mn - 0.2 * sig, vmax=mn + 2 * sig)
if rawxy != None:
rawx, rawy = rawxy
R = hdr['windowdx'] / 15.
plot(R * circle[0] + rawx - hdr['windowy0'],
R * circle[1] + rawy - hdr['windowx0'],
'-',
color='m',
alpha=0.7,
lw=2)
title(u"PUT CURSOR on your OBJECT", fontsize=16)
if not maxcr:
count = 0
for k in kol:
axvspan(k - 6,
k + 6,
0.01,
0.99,
facecolor='k',
alpha=0.3 - 0.02 * count)
count += 1
else:
k = k_sn_max[0][0]
axvspan(k - 10, k + 10, 0.01, 0.99, facecolor='k', alpha=0.2)
happy = False
skip = False
count = 0
while not happy:
print("put the cursor on the location of your source")
count += 1
coord = ginput(timeout=0)
print("selected:", coord)
if len(coord[0]) == 2:
print("window corner:", hdr['windowx0'], hdr['windowy0'])
xloc = coord[0][0] + hdr['windowx0']
yloc = coord[0][1] + hdr['windowy0']
print("on detector (full raw image) should be :", xloc, yloc)
#plot(coord[0][0],coord[0][1],'+',markersize=14,color='k',lw=2) #can't see it
axhspan(coord[0][1] - 6,
coord[0][1] + 6,
0,
1,
facecolor='k',
alpha=0.3)
if rawxy != None:
rawx, rawy = rawxy
R = hdr['windowdx'] / 15.
plot(R * circle[0] + rawx - hdr['windowx0'],
R * circle[1] + rawy - hdr['windowy0'],
'-',
color='k',
alpha=0.7,
lw=1)
#plot(rawx-hdr['windowx0'],rawy-hdr['windowy0'],'o',markersize=25,color='w',alpha=0.3)
ans = raw_input("happy (yes,skip,no): ")
if len(ans) > 0:
if ans.upper()[0] == 'Y':
happy = True
if ans.upper()[0] == 'S':
return 0.0, coord[0], (yloc + 104, xloc + 78)
else:
print("no position found")
if count > 10:
print("Too many tries: aborting")
happy = True
im = ''
try:
lss = 1.0
band = obs['band']
caldb = os.getenv('CALDB')
command = "quzcif swift uvota - "+band.upper()+\
" SKYFLAT "+\
obs['dateobs'].split('T')[0]+" "+\
obs['dateobs'].split('T')[1]+" - > lssfile.1234.tmp"
print(command)
os.system(command)
f = open('lssfile.1234.tmp')
lssfile = f.readline()
f.close()
f = fits.getdata(lssfile.split()[0], ext=int(lssfile.split()[1]))
lss = f[yloc, xloc]
print("lss correction = ", lss, " coords=", coord[0],
(yloc + 104, xloc + 78))
return lss, coord[0], (yloc + 104, xloc + 78)
except:
print("LSS correction cannot be determined.")
return 1.0, (0, 0), (1100.5, 1100.5)
#below is the repeat.
elif mark1 == 'Intensity': # if input file have the character'Intensity',call this method.
dr = read_csv(direct + fn,
sep=',',
skiprows=2,
parse_dates={'datet': [1]},
index_col='datet',
names=[
'NO', 'DataTime', 'Temp', 'Intensity', 'CouplerDetached',
'CouplerAttached', 'Stopped', 'EndOfFile'
])
df = DataFrame(dr['Temp'], index=dr.index)
fig = plt.figure()
plt.plot(df.index.to_pydatetime(), df.values)
print "click on start and stop times to save date"
[start, end] = pylab.ginput(n=2)
#plt.close()
plt.clf()
FF = chooseSE(start, end)
saveTemFig(dirout)
############generate the yeardays##############
yd = getyearday(FF)
#############c to f##################
FT = []
for k in range(len(FF.index)):
f = c2f(FF['Temp'][k])
FT.append(f)
############output file###################
PFDATA = {
'sitecode': Series(Sc, index=FF.index),
'depth': Series(dep, index=FF.index),
def draw_transects(output, settings):
"""
Draw shore-normal transects interactively on top of the mapped shorelines
KV WRL 2018
Arguments:
-----------
output: dict
contains the extracted shorelines and corresponding metadata
settings: dict with the following keys
'inputs': dict
input parameters (sitename, filepath, polygon, dates, sat_list)
Returns:
-----------
transects: dict
contains the X and Y coordinates of all the transects drawn.
Also saves the coordinates as a .geojson as well as a .jpg figure
showing the location of the transects.
"""
sitename = settings['inputs']['sitename']
filepath = os.path.join(settings['inputs']['filepath'], sitename)
# plot the mapped shorelines
fig1 = plt.figure()
ax1 = fig1.add_subplot(111)
ax1.axis('equal')
ax1.set_xlabel('Eastings [m]')
ax1.set_ylabel('Northings [m]')
ax1.grid(linestyle=':', color='0.5')
for i in range(len(output['shorelines'])):
sl = output['shorelines'][i]
date = output['dates'][i]
ax1.plot(sl[:, 0],
sl[:, 1],
'.',
markersize=3,
label=date.strftime('%d-%m-%Y'))
# ax1.legend()
fig1.set_tight_layout(True)
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
ax1.set_title(
'Click two points to define each transect (first point is the ' +
'origin of the transect and is landwards, second point seawards).\n' +
'When all transects have been defined, click on <ENTER>',
fontsize=16)
# initialise transects dict
transects = dict([])
counter = 0
# loop until user breaks it by click <enter>
while 1:
# let user click two points
pts = ginput(n=2, timeout=-1)
if len(pts) > 0:
origin = pts[0]
# if user presses <enter>, no points are selected
else:
# save figure as .jpg
fig1.gca().set_title('Transect locations', fontsize=16)
fig1.savefig(os.path.join(filepath, 'jpg_files',
sitename + '_transect_locations.jpg'),
dpi=200)
plt.title('Transect coordinates saved as ' + sitename +
'_transects.geojson')
plt.draw()
# wait 2 seconds for user to visualise the transects that are saved
ginput(n=1, timeout=2, show_clicks=True)
plt.close(fig1)
# break the loop
break
# add selectect points to the transect dict
counter = counter + 1
transect = np.array([pts[0], pts[1]])
# alternative of making the transect the origin, orientation and length
# temp = np.array(pts[1]) - np.array(origin)
# phi = np.arctan2(temp[1], temp[0])
# orientation = -(phi*180/np.pi - 90)
# length = np.linalg.norm(temp)
# transect = create_transect(origin, orientation, length)
transects[str(counter)] = transect
# plot the transects on the figure
ax1.plot(transect[:, 0], transect[:, 1], 'b-', lw=2.5)
ax1.plot(transect[0, 0], transect[0, 1], 'rx', markersize=10)
ax1.text(transect[-1, 0],
transect[-1, 1],
str(counter),
size=16,
bbox=dict(boxstyle="square", ec='k', fc='w'))
plt.draw()
# save transects.geojson
gdf = SDS_tools.transects_to_gdf(transects)
# set projection
gdf.crs = {'init': 'epsg:' + str(settings['output_epsg'])}
# save as geojson
gdf.to_file(os.path.join(filepath, sitename + '_transects.geojson'),
driver='GeoJSON',
encoding='utf-8')
# print the location of the files
print('Transect locations saved in ' + filepath)
return transects
def get_reference_sl(metadata, settings):
"""
Allows the user to manually digitize a reference shoreline that is used seed
the shoreline detection algorithm. The reference shoreline helps to detect
the outliers, making the shoreline detection more robust.
KV WRL 2018
Arguments:
-----------
metadata: dict
contains all the information about the satellite images that were downloaded
settings: dict with the following keys
'inputs': dict
input parameters (sitename, filepath, polygon, dates, sat_list)
'cloud_thresh': float
value between 0 and 1 indicating the maximum cloud fraction in
the cropped image that is accepted
'cloud_mask_issue': boolean
True if there is an issue with the cloud mask and sand pixels
are erroneously being masked on the images
'output_epsg': int
output spatial reference system as EPSG code
Returns:
-----------
reference_shoreline: np.array
coordinates of the reference shoreline that was manually digitized.
This is also saved as a .pkl and .geojson file.
"""
sitename = settings['inputs']['sitename']
filepath_data = settings['inputs']['filepath']
pts_coords = []
# check if reference shoreline already exists in the corresponding folder
filepath = os.path.join(filepath_data, sitename)
filename = sitename + '_reference_shoreline.pkl'
# if it exist, load it and return it
if filename in os.listdir(filepath):
print('Reference shoreline already exists and was loaded')
with open(
os.path.join(filepath, sitename + '_reference_shoreline.pkl'),
'rb') as f:
refsl = pickle.load(f)
return refsl
# otherwise get the user to manually digitise a shoreline on S2, L8 or L5 images (no L7 because of scan line error)
else:
# first try to use S2 images (10m res for manually digitizing the reference shoreline)
if 'S2' in metadata.keys():
satname = 'S2'
filepath = SDS_tools.get_filepath(settings['inputs'], satname)
filenames = metadata[satname]['filenames']
# if no S2 images, try L8 (15m res in the RGB with pansharpening)
elif not 'S2' in metadata.keys() and 'L8' in metadata.keys():
satname = 'L8'
filepath = SDS_tools.get_filepath(settings['inputs'], satname)
filenames = metadata[satname]['filenames']
# if no S2 images and no L8, use L5 images (L7 images have black diagonal bands making it
# hard to manually digitize a shoreline)
elif not 'S2' in metadata.keys() and not 'L8' in metadata.keys(
) and 'L5' in metadata.keys():
satname = 'L5'
filepath = SDS_tools.get_filepath(settings['inputs'], satname)
filenames = metadata[satname]['filenames']
else:
raise Exception(
'You cannot digitize the shoreline on L7 images (because of gaps in the images), add another L8, S2 or L5 to your dataset.'
)
# create figure
fig, ax = plt.subplots(1, 1, figsize=[18, 9], tight_layout=True)
mng = plt.get_current_fig_manager()
mng.window.showMaximized()
# loop trhough the images
for i in range(len(filenames)):
# read image
fn = SDS_tools.get_filenames(filenames[i], filepath, satname)
im_ms, georef, cloud_mask, im_extra, im_QA, im_nodata = preprocess_single(
fn, satname, settings['cloud_mask_issue'])
# calculate cloud cover
cloud_cover = np.divide(
sum(sum(cloud_mask.astype(int))),
(cloud_mask.shape[0] * cloud_mask.shape[1]))
# skip image if cloud cover is above threshold
if cloud_cover > settings['cloud_thresh']:
continue
# rescale image intensity for display purposes
im_RGB = rescale_image_intensity(im_ms[:, :, [2, 1, 0]],
cloud_mask, 99.9)
# plot the image RGB on a figure
ax.axis('off')
ax.imshow(im_RGB)
# decide if the image if good enough for digitizing the shoreline
ax.set_title(
'Press <right arrow> if image is clear enough to digitize the shoreline.\n'
+
'If the image is cloudy press <left arrow> to get another image',
fontsize=14)
# set a key event to accept/reject the detections (see https://stackoverflow.com/a/15033071)
# this variable needs to be immuatable so we can access it after the keypress event
skip_image = False
key_event = {}
def press(event):
# store what key was pressed in the dictionary
key_event['pressed'] = event.key
# let the user press a key, right arrow to keep the image, left arrow to skip it
# to break the loop the user can press 'escape'
while True:
btn_keep = plt.text(1.1,
0.9,
'keep ⇨',
size=12,
ha="right",
va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square",
ec='k',
fc='w'))
btn_skip = plt.text(-0.1,
0.9,
'⇦ skip',
size=12,
ha="left",
va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square",
ec='k',
fc='w'))
btn_esc = plt.text(0.5,
0,
'<esc> to quit',
size=12,
ha="center",
va="top",
transform=ax.transAxes,
bbox=dict(boxstyle="square", ec='k',
fc='w'))
plt.draw()
fig.canvas.mpl_connect('key_press_event', press)
plt.waitforbuttonpress()
# after button is pressed, remove the buttons
btn_skip.remove()
btn_keep.remove()
btn_esc.remove()
# keep/skip image according to the pressed key, 'escape' to break the loop
if key_event.get('pressed') == 'right':
skip_image = False
break
elif key_event.get('pressed') == 'left':
skip_image = True
break
elif key_event.get('pressed') == 'escape':
plt.close()
raise StopIteration(
'User cancelled checking shoreline detection')
else:
plt.waitforbuttonpress()
if skip_image:
ax.clear()
continue
else:
# create two new buttons
add_button = plt.text(0,
0.9,
'add',
size=16,
ha="left",
va="top",
transform=plt.gca().transAxes,
bbox=dict(boxstyle="square",
ec='k',
fc='w'))
end_button = plt.text(1,
0.9,
'end',
size=16,
ha="right",
va="top",
transform=plt.gca().transAxes,
bbox=dict(boxstyle="square",
ec='k',
fc='w'))
# add multiple reference shorelines (until user clicks on <end> button)
pts_sl = np.expand_dims(np.array([np.nan, np.nan]), axis=0)
geoms = []
while 1:
add_button.set_visible(False)
end_button.set_visible(False)
# update title (instructions)
ax.set_title(
'Click points along the shoreline (enough points to capture the beach curvature).\n'
+ 'Start at one end of the beach.\n' +
'When finished digitizing, click <ENTER>',
fontsize=14)
plt.draw()
# let user click on the shoreline
pts = ginput(n=50000, timeout=1e9, show_clicks=True)
pts_pix = np.array(pts)
# convert pixel coordinates to world coordinates
pts_world = SDS_tools.convert_pix2world(
pts_pix[:, [1, 0]], georef)
# interpolate between points clicked by the user (1m resolution)
pts_world_interp = np.expand_dims(np.array(
[np.nan, np.nan]),
axis=0)
for k in range(len(pts_world) - 1):
pt_dist = np.linalg.norm(pts_world[k, :] -
pts_world[k + 1, :])
xvals = np.arange(0, pt_dist)
yvals = np.zeros(len(xvals))
pt_coords = np.zeros((len(xvals), 2))
pt_coords[:, 0] = xvals
pt_coords[:, 1] = yvals
phi = 0
deltax = pts_world[k + 1, 0] - pts_world[k, 0]
deltay = pts_world[k + 1, 1] - pts_world[k, 1]
phi = np.pi / 2 - np.math.atan2(deltax, deltay)
tf = transform.EuclideanTransform(
rotation=phi, translation=pts_world[k, :])
pts_world_interp = np.append(pts_world_interp,
tf(pt_coords),
axis=0)
pts_world_interp = np.delete(pts_world_interp, 0, axis=0)
# save as geometry (to create .geojson file later)
geoms.append(geometry.LineString(pts_world_interp))
# convert to pixel coordinates and plot
pts_pix_interp = SDS_tools.convert_world2pix(
pts_world_interp, georef)
pts_sl = np.append(pts_sl, pts_world_interp, axis=0)
ax.plot(pts_pix_interp[:, 0], pts_pix_interp[:, 1], 'r--')
ax.plot(pts_pix_interp[0, 0], pts_pix_interp[0, 1], 'ko')
ax.plot(pts_pix_interp[-1, 0], pts_pix_interp[-1, 1], 'ko')
# update title and buttons
add_button.set_visible(True)
end_button.set_visible(True)
ax.set_title(
'click on <add> to digitize another shoreline or on <end> to finish and save the shoreline(s)',
fontsize=14)
plt.draw()
# let the user click again (<add> another shoreline or <end>)
pt_input = ginput(n=1, timeout=1e9, show_clicks=False)
pt_input = np.array(pt_input)
# if user clicks on <end>, save the points and break the loop
if pt_input[0][0] > im_ms.shape[1] / 2:
add_button.set_visible(False)
end_button.set_visible(False)
plt.title('Reference shoreline saved as ' + sitename +
'_reference_shoreline.pkl and ' + sitename +
'_reference_shoreline.geojson')
plt.draw()
ginput(n=1, timeout=3, show_clicks=False)
plt.close()
break
pts_sl = np.delete(pts_sl, 0, axis=0)
# convert world image coordinates to user-defined coordinate system
image_epsg = metadata[satname]['epsg'][i]
pts_coords = SDS_tools.convert_epsg(pts_sl, image_epsg,
settings['output_epsg'])
# save the reference shoreline as .pkl
filepath = os.path.join(filepath_data, sitename)
with open(
os.path.join(filepath,
sitename + '_reference_shoreline.pkl'),
'wb') as f:
pickle.dump(pts_coords, f)
# also store as .geojson in case user wants to drag-and-drop on GIS for verification
for k, line in enumerate(geoms):
gdf = gpd.GeoDataFrame(geometry=gpd.GeoSeries(line))
gdf.index = [k]
gdf.loc[k, 'name'] = 'reference shoreline ' + str(k + 1)
# store into geodataframe
if k == 0:
gdf_all = gdf
else:
gdf_all = gdf_all.append(gdf)
gdf_all.crs = {'init': 'epsg:' + str(image_epsg)}
# convert from image_epsg to user-defined coordinate system
gdf_all = gdf_all.to_crs(
{'init': 'epsg:' + str(settings['output_epsg'])})
# save as geojson
gdf_all.to_file(os.path.join(
filepath, sitename + '_reference_shoreline.geojson'),
driver='GeoJSON',
encoding='utf-8')
print('Reference shoreline has been saved in ' + filepath)
break
# check if a shoreline was digitised
if len(pts_coords) == 0:
raise Exception(
'No cloud free images are available to digitise the reference shoreline,'
+ 'download more images and try again')
return pts_coords
def forward_mapping():
img = cv2.imread('images/banner_small.jpg', 1)
triangle1, triangle2 = triangle(img)
im1 = np.array(triangle1, dtype=np.uint8)
plt.figure(3)
plt.imshow(triangle1)
plt.show()
x2 = [0, 0, im1.shape[0] - 1]
y2 = [0, im1.shape[1] - 1, 0]
fp2 = np.vstack((x2, y2))
im1 = np.fliplr(im1)
im1 = np.flipud(im1)
im2 = np.array(triangle2, dtype=np.uint8)
plt.figure(1)
plt.imshow(triangle2)
plt.show()
source_im1 = np.array(Image.open('images/tennis.jpg'), dtype=np.uint8)
source_im = cv2.cvtColor(source_im1, cv2.COLOR_BGR2RGB)
plt.figure(2)
plt.imshow(source_im)
plt.show()
max_row = source_im.shape[0] - 1
max_col = source_im.shape[1] - 1
x = [0, 0, im2.shape[0] - 1]
y = [0, im2.shape[1] - 1, 0]
fp = np.vstack((x, y))
#print("Click destination points, top-left, top-tight, and bottom-left corners")
tp = np.asarray(plt.ginput(n=3), dtype=np.float).T
tp = tp[[1, 0], :]
print('fp', fp)
print('tp', tp)
#print("Click destination points, top-right, bottorm-left, and bottom-right corners")
tp2 = np.asarray(plt.ginput(n=3), dtype=np.float).T
tp2 = tp2[[1, 0], :]
print('fp', fp2)
print('tp', tp2)
start = time.time()
#Using pseudoinverse
# Generating homogeneous coordinates
fph = np.vstack((fp, np.ones(fp.shape[1])))
tph = np.vstack((tp, np.ones(tp.shape[1])))
H = np.dot(tph, np.linalg.pinv(fph))
fph2 = np.vstack((fp2, np.ones(fp2.shape[1])))
tph2 = np.vstack((tp2, np.ones(tp2.shape[1])))
H2 = np.dot(tph2, np.linalg.pinv(fph2))
print('wat', (transform(H, fp) + .5).astype(np.int))
Cs = (transform(H, fp) + .5).astype(np.int)
Cs[Cs < 0] = 0
Cs[0, Cs[0] > max_row] = max_row
Cs[1, Cs[1] > max_col] = max_col
Cs2 = (transform(H2, fp2) + .5).astype(np.int)
Cs2[Cs2 < 0] = 0
Cs2[0, Cs2[0] > max_row] = max_row
Cs2[1, Cs2[1] > max_col] = max_col
#Generating pixel coordinate locations
ind = np.arange(im2.shape[0] * im2.shape[1])
row_vect = ind // im2.shape[1]
col_vect = ind % im2.shape[1]
coords = np.vstack((row_vect, col_vect))
new_coords = transform(H, coords).astype(np.int)
new_coords[new_coords < 0] = 255
new_coords[0, new_coords[0] > max_row] = max_row
new_coords[1, new_coords[1] > max_col] = max_col
target_im = source_im
# print('---------------------------')
# for y in range(im2.shape[0]):
# for x in range(im2.shape[1]):
# if(np.dot(im2[y,x],im2[y,x]) == 0 ):
# np.delete(im2, im2[y,x])
# print('---------------------------')
#
# print('---------------------------')
# for y in range(im1.shape[0]):
# for x in range(im1.shape[1]):
# if(np.dot(im1[y,x],im1[y,x]) == 0 ):
# np.delete(im1, im1[y,x])
# print('---------------------------')
target_im[new_coords[0], new_coords[1], :] = im2[coords[0], coords[1], :]
#Generating pixel coordinate locations
ind2 = np.arange(im1.shape[0] * im1.shape[1])
row_vect2 = ind2 // im2.shape[1]
col_vect2 = ind2 % im2.shape[1]
coords2 = np.vstack((row_vect2, col_vect2))
new_coords2 = transform(H2, coords2).astype(np.int)
target_im = source_im
target_im[new_coords2[0], new_coords2[1], :] = im1[coords2[0],
coords2[1], :]
elapsed_time = time.time() - start
print('Elapsed time: {0:.2f} '.format(elapsed_time))
cv2.imshow('image', target_im)
plt.figure(3)
plt.imshow(target_im)
plt.show()
