def logpolar(src, center, M): srcshape = src.shape[0:2] dstshape = (4096, 1024) return cv.warpPolar( src, dstshape, center, M, flags=cv.WARP_POLAR_LOG+cv.INTER_CUBIC+cv.WARP_FILL_OUTLIERS )
def check_screen(left, right, extra): global checked x, y = CENTER r = RADIUS screen = get_shot(0, x - r, y - r, 2 * r, 2 * r) rotated = cv.rotate(screen, cv.ROTATE_90_COUNTERCLOCKWISE) circle = cv.warpPolar(rotated, (300, 1000), (r, r), RADIUS, cv.WARP_POLAR_LINEAR) circle = cv.rotate(circle, cv.ROTATE_90_COUNTERCLOCKWISE) ring = circle[:150] if SAVE_SHOTS: dt = time.time() - T0 name = "shots/ring-%s+%s.png" % (T0, dt) cv.imwrite(name, ring) logger.info("%s Saved.", name) diffe, xe = get_match_x(ring, extra) checked += 1 xe += extra[0].shape[2] / 2 if diffe < 0.2: logger.info("Found Extra=%s", xe) return xe diff0, x0 = get_match_x(ring, left) diff1, x1 = get_match_x(ring, right) x1 += right[0].shape[1] if diff0 > 0.3 or diff1 > 0.3: name = "shots/NoMatch-{}+{}.png".format(T0, time.time() - T0) cv.imwrite(name, ring) logger.warning("Not Valid Match. diff=%s, %s, %s for %s", diffe, diff0, diff1, name) return None logger.info("Found left=%s, right=%s", x0, x1) return (x0 + x1) / 2
def to_log_polar_coords(image): flags = cv.INTER_LINEAR + cv.WARP_FILL_OUTLIERS + cv.WARP_POLAR_LOG w, h = image.shape[::-1] centre = (w / 2, h / 2) R = (w - 1) / 2 log_polar_img = cv.warpPolar(image, (w, h), centre, R, flags) return log_polar_img
def wrap_polar_face(image, width=config.DEFAULT_WRAP_POLAR_WIDTH, height=config.DEFAULT_WRAP_POLAR_HEIGHT, error_height=config.DEFAULT_WRAP_POLAR_HEIGHT_ERROR): """Wraps the clock face up. Args: image (numpy.ndarray): The clock face image. width (int, optional): The width of the final image. Defaults to config.WRAP_POLAR_WIDTH. height (int, optional): The height of the final image. Defaults to config.WRAP_POLAR_HEIGHT. error_height (int, optional): The error of the height. Defaults to config.DEFAULT_WRAP_POLAR_HEIGHT_ERROR Returns: numpy.narray: The final wrapped image. """ rotate = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE) centre = rotate.shape[0] // 2 polarImage = cv2.warpPolar( rotate, (height, width), (centre, centre), centre, cv2.INTER_CUBIC + cv2.WARP_FILL_OUTLIERS + cv2.WARP_POLAR_LINEAR) cropImage = copy.deepcopy(polarImage[0:width, error_height:height]) cropImage = cv2.rotate(cropImage, cv2.ROTATE_90_COUNTERCLOCKWISE) return cropImage
def polarConv(imgOrgin, outputName): global gammaCorrection h = imgOrgin.shape[0] #帧尺寸 w = imgOrgin.shape[1] #画像縮小 imgRedu = cv2.resize(imgOrgin, (math.floor( (NUMPIXELS * 2 - 1) / h * w), NUMPIXELS * 2 - 1)) #顺时针旋转90度 因为下一步的极坐标转换的0度是正东方向,而我们的POV正北方向为0度 imgRedu = cv2.rotate(imgRedu, cv2.ROTATE_90_CLOCKWISE) polar_image = cv2.warpPolar(imgRedu, (NUMPIXELS, Div), (imgRedu.shape[1] / 2, imgRedu.shape[0] / 2), min(imgRedu.shape[0], imgRedu.shape[1]) / 2, 0) for i in range(NUMPIXELS): #亮度处理 polar_image[:, i, 0] = polar_image[:, i, 0] * ( (100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright / 100 polar_image[:, i, 1] = polar_image[:, i, 1] * ( (100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright / 100 polar_image[:, i, 2] = polar_image[:, i, 2] * ( (100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright / 100 #polar_image[:,i,2] = hsv[:,i,2] * ((100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright /100 if (gammaCorrection): polar_image = cv2.LUT(polar_image, lut) cv2.imwrite(outputName + '.jpg', polar_image, [int(cv2.IMWRITE_JPEG_QUALITY), 100] + [int(cv2.IMWRITE_JPEG_OPTIMIZE), True])
def to_log_polar_coords(image): flags = cv.INTER_LINEAR + cv.WARP_FILL_OUTLIERS + cv.WARP_POLAR_LOG w, h = image.shape[::-1] centre = (w / 2, h / 2) max_radius = np.sqrt((w / 2)**2 + (h / 2)**2) log_polar_img = cv.warpPolar(image, (w, h), centre, max_radius, flags) #log_polar_img = cv.linearPolar(image, centre, max_radius, flags) return log_polar_img
def log_polar(img): ''' Convert image into log-polar space ''' rad_size = 2.0 center = (img.shape[0] / 2, img.shape[1] / 2) radius = round(sqrt(center[0] ** rad_size + center[1] ** rad_size)) return cv2.warpPolar(img, img.shape, center, radius, cv2.WARP_POLAR_LOG)
def warp_polar(img, circle): warped = cv2.warpPolar(img, dsize=(1000, warped_h), center=(circle[0], circle[1]), maxRadius=circle[2], flags=cv2.WARP_POLAR_LINEAR) d_imwrite("warp_polar.jpg", warped) return warped
def polar_plot(self,i): img=self.build_img(self.files[i]) img=self.img_processing(img) self.a=self.sym_axis(img) #value = np.sqrt(((img.shape[0]/2.0)**2.0)+((img.shape[1]/2.0)**2.0)) value=img.shape[0] polar_image = cv2.warpPolar(img,np.shape(img),(self.a,0), value, cv2.WARP_FILL_OUTLIERS) polar_image = polar_image.astype(np.uint8) plt.imshow(polar_image) plt.show()
def get_polar(img, radius, deg, px, py): flags = cv2.INTER_LINEAR + cv2.WARP_FILL_OUTLIERS + cv2.WARP_POLAR_LINEAR norm = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U) polar = cv2.warpPolar(norm, (radius, int(360 / deg)), (px, py), radius, flags) return polar
def img_processing(self,img,coordinate='Cartesian'): img=self.remove_background(img,self.img_background) img=self.crop(img,self.z_surf) img=self.threshold(img) a=self.sym_axis(img) value=img.shape[0] polar_image = cv2.warpPolar(img,np.shape(img),(a,0), value, cv2.WARP_FILL_OUTLIERS) if coordinate=='Cartesian': return img elif coordinate=='Polar': l=int(len(polar_image)/2) return polar_image[:l,:]
def transform_polar2cartesian(image): height, width = image.shape c = ( float(768 / 2.0), float(562 / 2.0) ) #Se define el centroide que se usa como referencia para la transformación imgRes = cv2.warpPolar( image, (height, width), c, 260, #Se realiza el cambio de coordenadas cv2.INTER_LINEAR + cv2.WARP_POLAR_LOG) imgRes = cv2.addWeighted( imgRes, 1.3, np.zeros(imgRes.shape, imgRes.dtype), 0, 0) #Se crea una imagen nueva con la transformación realizada return (imgRes) #Se retorna la imagen en coordenadas cartesianas
def raaft(patch, which_norm, inner=0, outer=1): """ Given an image patch and choice of norm, generate the RAAFT feature vector for that patch. Parameters ---------- patch : 2D numpy array The patch which we want to apply the RAAFT to. which_norm : float Which norm to normalize the feature vector by. Can choose any real number for this value, but choosing 1 <= which_norm <= infty is the most natural. Choosing either 1 or 2 works well in most cases. inner, outer : float To help with noise it is sometimes useful to set parts of the Fourier transform of in each patch to zero. If a patch has dimensions (px, py) then the points (kx,ky) in k-space which are not set to zero must satisfy: inner * sqrt(px^2 + py^2) <= sqrt(kx^2 + ky^2) outer * sqrt(px^2 + py^2) >= sqrt(kx^2 + ky^2) Returns ------- feat_vector : 2D numpy array with shape (patch.shape[0], 1) The RAAFT feature vector corresponding to the given patch. """ p_sz = patch.shape center = (p_sz[0] // 2, p_sz[1] // 2) rad = np.sqrt((p_sz[0]**2 + p_sz[1]**2) / 2) tol = 1e-10 # this so we don't accidentally divide by 0 # #patch = (patch - np.mean(patch)) / np.std(patch) # Take the absolute value of the Fourier transform tmp_img = np.abs(fftpack.fftshift(cv2.dct(patch))) # Normalize the patch tmp_img /= norm(np.ndarray.flatten(tmp_img), ord=which_norm) + tol # Perform the polar transform tmp_img = cv2.warpPolar(tmp_img, None, center, rad, cv2.WARP_FILL_OUTLIERS + cv2.INTER_CUBIC) # Sum over the radial variable feat_vec = np.sum(tmp_img, 0) feat_vec[:int(rad * inner)] = 0 feat_vec[int(rad * outer):] = 0 return np.array(feat_vec, ndmin=2)
def create_wedge(size, blur_radius=None): wedge = np.zeros((8, 1)) wedge[1::4] = 1 wedge[2::4] = 1 wedge = resize(wedge, size, order=0) if blur_radius is not None: wedge = cv2.blur(wedge, (1, int(blur_radius / 360 * size[1]))) wedge = cv2.warpPolar( wedge, size, tuple([s / 2 for s in size]), size[0], cv2.WARP_INVERSE_MAP, ) wedge[tuple([int(s / 2) for s in size])] = 0.5 return wedge
def getPolar2CartImg(image, rad): c = (float(np.size(image, 0)/2.0), float(np.size(image, 1)/2.0)) imgRes = cv.warpPolar(image, (rad*3,360), c, np.size(image, 0)/2, cv.WARP_POLAR_LOG) for valid_width in reversed(range(rad*3)): blank_cnt = 0 for h in range(360): if (imgRes[h][valid_width] != 0): blank_cnt+=1 if(blank_cnt == 0): imgRes = imgRes[0:360, valid_width:rad*3] break imgRes = cv.resize(imgRes, (80, 360), interpolation=cv.INTER_CUBIC) return imgRes
def process(self, a: np.ndarray) -> np.ndarray: """ Based on code taken from: https://stackoverflow.com/questions/51675940/converting-an-image-from-cartesian-to-polar-limb-darkening """ # cv2.warpPolar only works on two dimensional arrays. If the # array is three dimensional, call process recursively with # each two-dimensional slice of the three-dimensional array. if len(a.shape) == 3: for index in range(a.shape[Z]): a[index] = self.process(a[index]) return a # Roll the image into polar coordinates. center = tuple([n / 2 for n in a.shape]) max_radius = np.sqrt(sum(n**2 for n in center)) flags = cv2.WARP_POLAR_LINEAR + cv2.WARP_INVERSE_MAP return cv2.warpPolar(a, a.shape, center, max_radius, flags)
def shot(): x, y = CENTER r = RADIUS screen = get_shot(0, x - r, y - r, 2 * r, 2 * r) logger.info("Screen Capurted") cv.imwrite("images/screen.png", screen) rotated = cv.rotate(screen, cv.ROTATE_90_COUNTERCLOCKWISE) logger.info("Rotate End") circle = cv.warpPolar(rotated, (300, 1000), (r, r), RADIUS, cv.WARP_POLAR_LINEAR) logger.info("warpPolar End") circle = cv.rotate(circle, cv.ROTATE_90_COUNTERCLOCKWISE) logger.info("Rotate End") ring = circle[:150] logger.info("All Transform End") cv.imwrite("images/ring.png", ring) logger.info("Saved")
def get_filter(self): lidar_range_pix = int(LidarSpec.RANGE * self.XY_resolution) filter_size = lidar_range_pix * 2 poler_filter = np.zeros((self.angle_resolution, lidar_range_pix), dtype=float) map_filter = np.zeros( (self.angle_resolution, filter_size, filter_size)) flags = cv2.INTER_CUBIC + cv2.WARP_FILL_OUTLIERS + cv2.WARP_POLAR_LINEAR + cv2.WARP_INVERSE_MAP for angle_pix in range(0, self.angle_resolution): poler_filter.fill(0.0) poler_filter[angle_pix, :] = 1.0 map_filter[angle_pix] = cv2.warpPolar( poler_filter, (filter_size, filter_size), (lidar_range_pix, lidar_range_pix), lidar_range_pix, flags) return map_filter, filter_size
def estCorrect(orgImg0, cutoffF=0.8, margin=0.1): orgImg = cv2.fastNlMeansDenoisingColored(orgImg0, None, 9, 9, 7, 21) w = orgImg.shape[1] crop_img = orgImg[:, int(margin * w):int(w - margin * w)] pix_color = np.array(crop_img) full_pix_color = np.array(orgImg) img = rgb2gray(pix_color) img = abs(img[0:-1, :] - img[1:, :]) f = np.fft.fft2(img) fshift = np.fft.fftshift(f) magnitude_spectrum = 20 * np.log(np.abs(fshift)) #plt.subplot(143),plt.imshow(np.abs(fshift), cmap = 'gray') #plt.title('np.abs(fshift)'), plt.xticks([]), plt.yticks([]) margin = 0.9 # Cut off the outer 10% of the image # Do the polar rotation along 100 angular steps with a radius of 256 pixels. size = min(img.shape) polar_img = cv2.warpPolar(magnitude_spectrum, (int(size / 2), 200), (img.shape[1] / 2, img.shape[0] / 2), size * margin * 0.5, cv2.WARP_POLAR_LINEAR) polar_img_lowF = polar_img[:, int(0.01 * polar_img.shape[1]):int(cutoffF * polar_img.shape[1])] polar_sum_200 = np.sum(polar_img_lowF, axis=1) polar_sum = polar_sum_200[0:100] + polar_sum_200[100:200] #polar_sum[50]=min(polar_sum) #matthew do not count center line #print(statistics.stdev(polar_sum[25:75])) maxIndex = np.argmax(polar_sum[25:75]) + 25 offsetDegree = (maxIndex - 50) / 100 * 3.14 aEst = np.sin(offsetDegree) full_pix_color0 = np.array(orgImg0) correctImg = imgWrapA(full_pix_color0, aEst) #full_pix_color #polar_sum[25:75]=min(polar_sum) #matthew do not count center line #maxIndex2=np.argmax(polar_sum) #print("maxIndex2={}".format(maxIndex2)) return correctImg
def polarConv(imgOrgin): h = imgOrgin.height #帧尺寸 w = imgOrgin.width #画像縮小 imgRedu = cv2.resize(np.array(imgOrgin),(math.floor((NUMPIXELS * 2 -1)/h *w), NUMPIXELS * 2 -1)) #顺时针旋转90度 因为下一步的极坐标转换的0度是正东方向,而我们的POV正北方向为0度 imgRedu = cv2.rotate(imgRedu,cv2.ROTATE_90_CLOCKWISE) polar_image = cv2.warpPolar(imgRedu,(NUMPIXELS , Div ), (imgRedu.shape[1]/2,imgRedu.shape[0]/2) ,min(imgRedu.shape[0], imgRedu.shape[1]) / 2, 0) for i in range(NUMPIXELS): #亮度处理 polar_image[:,i,0] = polar_image[:,i,0] * ((100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright /100 polar_image[:,i,1] = polar_image[:,i,1] * ((100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright /100 polar_image[:,i,2] = polar_image[:,i,2] * ((100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright /100 #polar_image[:,i,2] = hsv[:,i,2] * ((100 - Led0Bright) / NUMPIXELS * i + Led0Bright) / 100 * Bright /100 #cv2.imwrite(outputName+'.jpg',polar_image,[int(cv2.IMWRITE_JPEG_OPTIMIZE), True]) ret,img_encode = cv2.imencode('.jpg',polar_image,[int(cv2.IMWRITE_JPEG_QUALITY), 50]+[int(cv2.IMWRITE_JPEG_OPTIMIZE), True]) data = np.array(img_encode) stringData = data.tobytes() print(str(len(stringData))) s.send(str.encode(str(len(stringData)).ljust(5)+'\r')); s.sendall(stringData)
def mask_circle_and_wrap_polar(img): try: x, y, rad = get_center_circle(img) if abs(rad - settings.SMALL_RADIUS_SIZE) < abs(rad - settings.MED_RADIUS_SIZE): rad = settings.BIG_RADIUS_SIZE / settings.SMALL_RADIUS_SIZE * rad elif abs(rad - settings.MED_RADIUS_SIZE) < abs(rad - settings.BIG_RADIUS_SIZE): rad = settings.BIG_RADIUS_SIZE / settings.MED_RADIUS_SIZE * rad except TypeError: x, y = settings.AVERAGE_CENTER rad = settings.BIG_RADIUS_SIZE dim = settings.OUTPUT_IMG_DIMENSION return cv2.warpPolar( img, (dim, dim), (x, y), int(settings.CIRCLE_PERC_FILTER * rad), cv2.WARP_POLAR_LINEAR, )
def get_Likelihood_function(self, robot_position): tuples = [(0, 0)] for robot_pix in self.pos_to_pix(robot_position): try: tuples += [ self.pad_tuple(self._filter_size, self.pixels_len, robot_pix) ] except ArithmeticError as error: print(error) print(tuples) ajusted_filter = np.pad(self._filter, tuples, constant_values=0) print(ajusted_filter.shape) likelihood_poler = np.sum(self.data * ajusted_filter, axis=0) flags = cv2.INTER_CUBIC + cv2.WARP_FILL_OUTLIERS + cv2.WARP_POLAR_LINEAR + cv2.WARP_INVERSE_MAP likelihood = cv2.warpPolar(likelihood_poler, (self.angle_resolution, self.pixels_len), (self._origin_pixel, self._origin_pixel), self.pixels_len, flags) return likelihood, likelihood_poler, ajusted_filter
if capture is None: print("Video not found.", file=sys.stderr) sys.exit(1) fourcc = cv2.VideoWriter_fourcc(*'MJPG') output_size = (int(capture.get(cv2.CAP_PROP_FRAME_WIDTH)), int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))) fps = capture.get(cv2.CAP_PROP_FPS) output = cv2.VideoWriter('logpolar.avi', fourcc, fps, output_size, isColor=1) captured, frame = capture.read() key = 0 while captured and key != ENTER: width, height = output_size logpolar_frame = cv2.warpPolar( src=frame, dsize=output_size, center=(width // 2, height // 2), maxRadius=40, flags=cv2.INTER_LINEAR + cv2.WARP_FILL_OUTLIERS + cv2.WARP_INVERSE_MAP) output.write(logpolar_frame) cv2.imshow('video', frame) cv2.imshow('Logpolar', logpolar_frame) captured, frame = capture.read() key = cv2.waitKey(delay=33) capture.release() output.release() cv2.destroyAllWindows()
import cv2 import numpy as np img = cv2.imread("polar_remap_doc.png") dst = cv2.warpPolar(img, (176, 1106), (234, 208), 176, cv2.INTER_NEAREST + cv2.WARP_POLAR_LINEAR) cv2.namedWindow('r', 0) cv2.resizeWindow('r', 640, 480) cv2.imshow('r', dst) cv2.waitKey(0) cv2.imshow('r', img) cv2.waitKey(0)
def get_polar(img, radius, deg, px, py): flags = cv2.INTER_LINEAR + cv2.WARP_FILL_OUTLIERS + cv2.WARP_POLAR_LINEAR polar = cv2.warpPolar(img, (radius, int(360/deg)), (px, py), radius, flags) return polar
import cv2 from skimage.feature import register_translation import numpy as np import matplotlib.pyplot as plt fnames = [ "/data1/mschroeder/Datasets/18-10-SedimentTrap-Fred/M138 T4 600A/T4 600A 13.jpeg", "/data1/mschroeder/Datasets/18-10-SedimentTrap-Fred/M138 T4 600A/T4 600A 3.jpeg" ] frames = [cv2.imread(fn) for fn in fnames] frames_pol = [] for f in frames: print(f.shape) center = f.shape[0] / 2, f.shape[1] / 2 frames_pol.append( cv2.warpPolar(f, (0, 0), center, max(center), cv2.WARP_POLAR_LOG + cv2.WARP_FILL_OUTLIERS)) for f in frames_pol: print(f.shape) # Subpixel-accurate registration # translation = register_translation(frames_pol[0][...,0], frames_pol[1][...,0]) image_product = np.fft.fft2(frames_pol[0][..., 0]) * np.fft.fft2( frames_pol[1][..., 0]).conj() cc_image = np.fft.fftshift(np.fft.ifft2(image_product)) plt.imshow(cc_image.real)
# pulls a random circle - in theory, this is the only one that should be found, but this isn't always certain depending on noise trueCenter = None for i in circles[0]: if ((np.abs(i[1] - center[0])**2 + np.abs(i[0] - center[1])**2)**0.5 < 35): trueCenter = i # draw the outer circle cv2.circle(cimg, (i[0], i[1]), i[2], (0, 255, 0), 2) # draw the center of the circle cv2.circle(cimg, (i[0], i[1]), 2, (0, 0, 255), 3) #transform to polar and draw image - do this twice, once for the image to display, #and once for the one to do the math on (which should not have debug graphics - eg the center of the circle drawn) size = int(np.shape(img)[0] / 2) dst = cv2.warpPolar(cimg, (size, size), (trueCenter[0], trueCenter[1]), maxRadius=size, flags=cv2.WARP_POLAR_LINEAR) dst2 = cv2.warpPolar(bwimg, (size, size), (trueCenter[0], trueCenter[1]), maxRadius=size, flags=cv2.WARP_POLAR_LINEAR) #plot intensities and figures fig = plt.figure() plt.subplot(2, 2, 1) plt.imshow(cimg) plt.subplot(2, 2, 2) #plot pixel intensities from center to the side of the image (bad way) plt.plot( range(0, len(bwimg[trueCenter[1]]))[trueCenter[0]:],
center = (0, 0) radius = 0 #***************Az ora körvonalanak megkeresese************************************* if circles is not None: circles = np.uint16(np.around(circles)) for i in circles[0, :]: center = (i[0], i[1]) cv2.circle(src, center, 1, (255, 0, 0), 3) radius = i[2] cv2.circle(src, center, radius, (0, 0, 255), 3) #**********Az ora 'kiteritese'******************************************************* polar = cv2.warpPolar(src, (0, 0), center, radius, cv2.WARP_POLAR_LINEAR) (h, w) = polar.shape[:2] polar_center = (w / 2, h / 2) M = cv2.getRotationMatrix2D(polar_center, 180, 1.0) polar = cv2.warpAffine(polar, M, (w, h)) polar = cv2.resize(polar, None, fx=2.0, fy=1.0, interpolation=cv2.INTER_LINEAR) #**********A kiteritett kepen elvegzem az inverz binaris kuszobolest****************** ret, polar = cv2.threshold(polar, 120, 255, cv2.THRESH_BINARY) struct = cv2.getStructuringElement(cv2.MORPH_RECT, (40, 1))
def center_estimation_Combot2020(sar, lon1st, lat1st, hetero_thresh=0.5): hetero_mask = sar.heterogeneity_mask.values < 0.5 xx, yy = np.meshgrid(sar.lon, sar.lat) xx -= lon1st yy -= lat1st dist = np.sqrt(xx**2 + yy**2) * 110 #km dist_mask = dist < 50 co_contrast = np.nanmax(sar.nrcs_co.values[dist_mask]) - np.nanmin( sar.nrcs_co.values[dist_mask]) cross_contrast = np.nanmax( sar.nrcs_cross.values[dist_mask]) - np.nanmin( sar.nrcs_cross.values[dist_mask]) co_is_larger_contrast = co_contrast > cross_contrast nrcs = sar.nrcs_co if co_is_larger_contrast else nrcs_cross nrcs_masked = np.where(dist_mask, nrcs, np.nanmax(nrcs)) lat2nd_ind, lon2nd_ind = np.where( nrcs_masked == np.nanmin(nrcs_masked)) lon2nd = sar.lon[lon2nd_ind].values.mean() lat2nd = sar.lat[lat2nd_ind].values.mean() lon2nd_ind = np.where(sar.lon == lon2nd)[0] lat2nd_ind = np.where(sar.lat == lat2nd)[0] polar_radius = int(100 / (110 * (sar.lat[0] - sar.lat[1]))) flags = cv2.INTER_LINEAR + cv2.WARP_FILL_OUTLIERS + cv2.WARP_POLAR_LINEAR nrcs_norm = cv2.normalize(nrcs.values * hetero_mask, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U) nrcs_polar = cv2.warpPolar(nrcs_norm, (polar_radius, int(360 / 0.5)), (lon2nd_ind, lat2nd_ind), polar_radius, flags) wind_norm = cv2.normalize(sar.wind_speed.values * hetero_mask, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U) wind_polar = cv2.warpPolar(wind_norm, (polar_radius, int(360 / 0.5)), (lon2nd_ind, lat2nd_ind), polar_radius, flags) nrcs_diff = np.diff(nrcs_polar.astype(np.float), axis=1) wind_diff = np.diff(wind_polar.astype(np.float), axis=1) diff = nrcs_diff + wind_diff blurred_diff = ndi.gaussian_filter(diff, sigma=5) eye_extents = np.argmax(blurred_diff, axis=1) # align with 0.5 deg dirs_crockwise_from_east = np.arange(0, 360, 0.5) eye_ext_xs = eye_extents * np.cos( np.deg2rad(dirs_crockwise_from_east)) + lon2nd_ind eye_ext_ys = eye_extents * np.sin( np.deg2rad(dirs_crockwise_from_east)) + lat2nd_ind x = int(eye_ext_xs.mean()) y = int(eye_ext_ys.mean()) lon = sar.lon.values[x] lat = sar.lat.values[y] misc = { "lon2nd": lon2nd, "lat2nd": lat2nd, "eye_xs": eye_ext_xs, "eye_ys": eye_ext_ys } return lon, lat, misc
def get_cart(img, radius, width, height): flags = cv2.INTER_LINEAR + cv2.WARP_FILL_OUTLIERS + cv2.WARP_INVERSE_MAP cart = cv2.warpPolar(img, (width, height), (width // 2, height // 2), radius, flags) return cart