def match(desc1, desc2): """ for each descriptor in the first image, select its match in the second image. input: desc1 (descriptors for the first image), desc2 (same for second image). """ desc1 = array([d / linalg.norm(d) for d in desc1]) desc2 = array([d / linalg.norm(d) for d in desc2]) dist_ratio = 0.6 desc1_size = desc1.shape matchscores = zeros((desc1_size[0], 1)) desc2t = desc2.T # precompute matrix transpose for i in range(desc1_size[0]): dotprods = dot(desc1[i, :], desc2t) # vector of dot products dotprods = 0.9999 * dotprods # inverse cosine and sort, return index for features in second image indx = argsort(arccos(dotprods)) #check if nearest neighbor has angle less than dist_ratio times 2nd if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]: matchscores[i] = int(indx[0]) return matchscores
def cache_angles(tile_size=500): half_size = float(tile_size - 1) / 2 get_zp = lambda x, y: arccos(1 / sqrt(x**2 + y**2 + 1)) get_zm = lambda x, y: arccos(-1 / sqrt(x**2 + y**2 + 1)) get_xypm = lambda x, y: arccos(y / sqrt(x**2 + y**2 + 1)) get_phi = lambda x, y: arctan(float(y) / x) cache = { 'zp': np.zeros((tile_size, tile_size, ), dtype=np.float), 'zm': np.zeros((tile_size, tile_size, ), dtype=np.float), 'xypm': np.zeros((tile_size, tile_size, ), dtype=np.float), 'phi': np.zeros((tile_size, tile_size, ), dtype=np.float) } print 'Perform cache angles...' for tile_y in xrange(tile_size): y = float(tile_y) / half_size - 1 for tile_x in xrange(tile_size): x = float(tile_x) / half_size - 1 cache['zp'][tile_y, tile_x] = get_zp(x, y) cache['zm'][tile_y, tile_x] = get_zm(x, y) cache['xypm'][tile_y, tile_x] = get_xypm(x, y) if x != 0: cache['phi'][tile_y, tile_x] = get_phi(x, y) # print 'cache for: [{}, {}] -> [{},{}]'.format(tile_y, tile_x, y, x) return cache
def test_testUfuncs1(self): # Test various functions such as sin, cos. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d assert_(eq(np.cos(x), cos(xm))) assert_(eq(np.cosh(x), cosh(xm))) assert_(eq(np.sin(x), sin(xm))) assert_(eq(np.sinh(x), sinh(xm))) assert_(eq(np.tan(x), tan(xm))) assert_(eq(np.tanh(x), tanh(xm))) with np.errstate(divide='ignore', invalid='ignore'): assert_(eq(np.sqrt(abs(x)), sqrt(xm))) assert_(eq(np.log(abs(x)), log(xm))) assert_(eq(np.log10(abs(x)), log10(xm))) assert_(eq(np.exp(x), exp(xm))) assert_(eq(np.arcsin(z), arcsin(zm))) assert_(eq(np.arccos(z), arccos(zm))) assert_(eq(np.arctan(z), arctan(zm))) assert_(eq(np.arctan2(x, y), arctan2(xm, ym))) assert_(eq(np.absolute(x), absolute(xm))) assert_(eq(np.equal(x, y), equal(xm, ym))) assert_(eq(np.not_equal(x, y), not_equal(xm, ym))) assert_(eq(np.less(x, y), less(xm, ym))) assert_(eq(np.greater(x, y), greater(xm, ym))) assert_(eq(np.less_equal(x, y), less_equal(xm, ym))) assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym))) assert_(eq(np.conjugate(x), conjugate(xm))) assert_(eq(np.concatenate((x, y)), concatenate((xm, ym)))) assert_(eq(np.concatenate((x, y)), concatenate((x, y)))) assert_(eq(np.concatenate((x, y)), concatenate((xm, y)))) assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
def test_testUfuncs1(self): # Test various functions such as sin, cos. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d assert_(eq(np.cos(x), cos(xm))) assert_(eq(np.cosh(x), cosh(xm))) assert_(eq(np.sin(x), sin(xm))) assert_(eq(np.sinh(x), sinh(xm))) assert_(eq(np.tan(x), tan(xm))) assert_(eq(np.tanh(x), tanh(xm))) with np.errstate(divide='ignore', invalid='ignore'): assert_(eq(np.sqrt(abs(x)), sqrt(xm))) assert_(eq(np.log(abs(x)), log(xm))) assert_(eq(np.log10(abs(x)), log10(xm))) assert_(eq(np.exp(x), exp(xm))) assert_(eq(np.arcsin(z), arcsin(zm))) assert_(eq(np.arccos(z), arccos(zm))) assert_(eq(np.arctan(z), arctan(zm))) assert_(eq(np.arctan2(x, y), arctan2(xm, ym))) assert_(eq(np.absolute(x), absolute(xm))) assert_(eq(np.equal(x, y), equal(xm, ym))) assert_(eq(np.not_equal(x, y), not_equal(xm, ym))) assert_(eq(np.less(x, y), less(xm, ym))) assert_(eq(np.greater(x, y), greater(xm, ym))) assert_(eq(np.less_equal(x, y), less_equal(xm, ym))) assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym))) assert_(eq(np.conjugate(x), conjugate(xm))) assert_(eq(np.concatenate((x, y)), concatenate((xm, ym)))) assert_(eq(np.concatenate((x, y)), concatenate((x, y)))) assert_(eq(np.concatenate((x, y)), concatenate((xm, y)))) assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
# The surface of the Earth is curved, and the distance between degrees of longitude # varies with latitude. As a result, finding the distance between two points on the surface # of the Earth is more complicated than simply using the Pythagorean theorem. # Let (t1, g1) and (t2, g2) be the latitude and longitude of two points on the Earth’s # surface. The distance between these points, following the surface of the Earth, in # kilometers is: # distance = 6371.01 × arccos(sin(t1) × sin(t2) + cos(t1) × cos(t2) × cos(g1 − g2)) # The value 6371.01 in the previous equation wasn’t selected at random. It is # the average radius of the Earth in kilometers. # Create a program that allows the user to enter the latitude and longitude of two # points on the Earth in degrees. Your program should display the distance between # the points, following the surface of the earth, in kilometers. # Hint: Python’s trigonometric functions operate in radians. As a result, you will # need to convert the user’s input from degrees to radians before computing the # distance with the formula discussed previously. The math module contains a # function named radians which converts from degrees to radians. from math import sin, cos, radians from numpy.ma import arccos t1 = radians(float(input('Enter longitude of the first point:'))) g1 = radians(float(input('Enter latitude of the first point:'))) t2 = radians(float(input('Enter longitude of the second point:'))) g2 = radians(float(input('Enter latitude of the second point:'))) RADIUS = 6371.01 distance = RADIUS * arccos( sin(t1) * sin(t2) + cos(t1) * cos(t2) * cos(g1 - g2)) print('The distance between the points is', distance)
def theta(i, N): return arccos(-1 + 2 * i / (N - 1))