def getThresholdedStripe3DPoints(config, img_handle, frame_min, frame_max, rho, theta, mask, flat_struct, \ dark, stripe_width_factor=1.0, centroiding=False, point1=None, point2=None, debug=False): """ Threshold the image and get a list of pixel positions and frames of threshold passers. This function handles all input types of data. Arguments; config: [config object] configuration object (loaded from the .config file). img_handle: [FrameInterface instance] Object which has a common interface to various input files. frame_min: [int] First frame to process. frame_max: [int] Last frame to process. rho: [float] Line distance from the center in HT space (pixels). theta: [float] Angle in degrees in HT space. mask: [ndarray] Image mask. flat_struct: [Flat struct] Structure containing the flat field. None by default. dark: [ndarray] Dark frame. Keyword arguments: stripe_width_factor: [float] Multipler by which the default stripe width will be multiplied. Default is 1.0 centroiding: [bool] If True, the indices will be returned in the centroiding mode, which means that point1 and point2 arguments must be given. point1: [list] (x, y, frame) Of the first reference point of the detection. point2: [list] (x, y, frame) Of the second reference point of the detection. debug: [bool] If True, extra debug messages and plots will be shown. Return: xs, ys, zs: [tuple of lists] Indices of (x, y, frame) of threshold passers for every frame. """ # Get indices of stripe pixels around the line of the meteor img_h, img_w = img_handle.ff.maxpixel.shape stripe_indices = getStripeIndices( rho, theta, stripe_width_factor * config.stripe_width, img_h, img_w) # If centroiding should be done, prepare everything for cutting out parts of the image for photometry if centroiding: # Compute the unit vector which describes the motion of the meteor in the image domain point1 = np.array(point1) point2 = np.array(point2) motion_vect = point2[:2] - point1[:2] motion_vect_unit = vectNorm(motion_vect) # Get coordinates of 2 points that describe the line x1, y1, z1 = point1 x2, y2, z2 = point2 # Compute the average angular velocity in px per frame ang_vel = np.sqrt((x2 - x1)**2 + (y2 - y1)**2) / (z2 - z1) # Compute the vector describing the length and direction of the meteor per frame motion_vect = ang_vel * motion_vect_unit # If the FF files is given, extract the points from FF after threshold if img_handle.input_type == 'ff': # Threshold the FF file img_thres = Image.thresholdFF(img_handle.ff, config.k1_det, config.j1_det, mask=mask, \ mask_ave_bright=False) # Extract the thresholded image by min and max frames from FF file img = selectFFFrames(np.copy(img_thres), img_handle.ff, frame_min, frame_max) # Remove lonely pixels img = morph.clean(img) # Extract the stripe from the thresholded image stripe = np.zeros(img.shape, img.dtype) stripe[stripe_indices] = img[stripe_indices] # Show stripe # show2("stripe", stripe*255) # Show 3D could # show3DCloud(ff, stripe) # Get stripe positions (x, y, frame) stripe_positions = stripe.nonzero() xs = stripe_positions[1] ys = stripe_positions[0] zs = img_handle.ff.maxframe[stripe_positions] return xs, ys, zs # If video frames are available, extract indices on all frames in the given range else: xs_array = [] ys_array = [] zs_array = [] # Go through all frames in the frame range for fr in range(frame_min, frame_max + 1): # Break the loop if outside frame size if fr == (img_handle.total_frames - 1): break # Set the frame number img_handle.setFrame(fr) # Load the frame fr_img = img_handle.loadFrame() # Apply the dark frame if dark is not None: fr_img = Image.applyDark(fr_img, dark) # Apply the flat to frame if flat_struct is not None: fr_img = Image.applyFlat(fr_img, flat_struct) # Mask the image fr_img = MaskImage.applyMask(fr_img, mask) # Threshold the frame img_thres = Image.thresholdImg(fr_img, img_handle.ff.avepixel, img_handle.ff.stdpixel, \ config.k1_det, config.j1_det, mask=mask, mask_ave_bright=False) # Remove lonely pixels img_thres = morph.clean(img_thres) # Extract the stripe from the thresholded image stripe = np.zeros(img_thres.shape, img_thres.dtype) stripe[stripe_indices] = img_thres[stripe_indices] # Include more pixels for centroiding and photometry and mask out per frame pixels if centroiding: # Dilate the pixels in the stripe twice, to include more pixels for photometry stripe = morph.dilate(stripe) stripe = morph.dilate(stripe) # Get indices of the stripe that is perpendicular to the meteor, and whose thickness is the # length of the meteor on this particular frame - this is called stripe_indices_motion # Compute the previous, current, and the next linear model position of the meteor on the # image model_pos_prev = point1[:2] + (fr - 1 - z1) * motion_vect model_pos = point1[:2] + (fr - z1) * motion_vect model_pos_next = point1[:2] + (fr + 1 - z1) * motion_vect # Get the rho, theta of the line perpendicular to the meteor line x_inters, y_inters = model_pos # Check if the previous, current or the next centroids are outside bounds, and if so, skip the # frame if (not checkCentroidBounds(model_pos_prev, img_w, img_h)) or \ (not checkCentroidBounds(model_pos, img_w, img_h)) or \ (not checkCentroidBounds(model_pos_next, img_w, img_h)): continue # Get parameters of the perpendicular line to the meteor line rho2, theta2 = htLinePerpendicular(rho, theta, x_inters, y_inters, img_h, img_w) # Compute the image indices of this position which will be the intersection with the stripe # The width of the line will be 2x the angular velocity stripe_length = 6 * ang_vel if stripe_length < stripe_width_factor * config.stripe_width: stripe_length = stripe_width_factor * config.stripe_width stripe_indices_motion = getStripeIndices( rho2, theta2, stripe_length, img_h, img_w) # Mark only those parts which overlap both lines, which effectively creates a mask for # photometry an centroiding, excluding other influences stripe_new = np.zeros_like(stripe) stripe_new[stripe_indices_motion] = stripe[ stripe_indices_motion] stripe = stripe_new if debug: # Show the extracted stripe img_stripe = np.zeros_like(stripe) img_stripe[stripe_indices] = 1 final_stripe = np.zeros_like(stripe) final_stripe[stripe_indices_motion] = img_stripe[ stripe_indices_motion] plt.imshow(final_stripe) plt.show() if debug and centroiding: print(fr) print('mean stdpixel3:', np.mean(img_handle.ff.stdpixel)) print('mean avepixel3:', np.mean(img_handle.ff.avepixel)) print('mean frame:', np.mean(fr_img)) fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True, sharey=True) fr_img_noavg = Image.applyDark(fr_img, img_handle.ff.avepixel) #fr_img_noavg = fr_img # Auto levels min_lvl = np.percentile(fr_img_noavg[2:, :], 1) max_lvl = np.percentile(fr_img_noavg[2:, :], 99.0) # Adjust levels fr_img_autolevel = Image.adjustLevels(fr_img_noavg, min_lvl, 1.0, max_lvl) ax1.imshow(stripe, cmap='gray') ax2.imshow(fr_img_autolevel, cmap='gray') plt.show() pass # Get stripe positions (x, y, frame) stripe_positions = stripe.nonzero() xs = stripe_positions[1] ys = stripe_positions[0] zs = np.zeros_like(xs) + fr # Add the points to the list xs_array.append(xs) ys_array.append(ys) zs_array.append(zs) if debug: print('---') print(stripe.nonzero()) print(xs, ys, zs) if len(xs_array) > 0: # Flatten the arrays xs_array = np.concatenate(xs_array) ys_array = np.concatenate(ys_array) zs_array = np.concatenate(zs_array) else: xs_array = np.array(xs_array) ys_array = np.array(ys_array) zs_array = np.array(zs_array) return xs_array, ys_array, zs_array
def extractStars(ff_dir, ff_name, config=None, max_global_intensity=150, border=10, neighborhood_size=10, intensity_threshold=5, flat_struct=None, dark=None, mask=None): """ Extracts stars on a given FF bin by searching for local maxima and applying PSF fit for star confirmation. Source of one part of the code: http://stackoverflow.com/questions/9111711/get-coordinates-of-local-maxima-in-2d-array-above-certain-value Arguments: ff_dir: [str] Path to directory where FF files are. ff_name: [str] Name of the FF file. config: [config object] configuration object (loaded from the .config file) max_global_intensity: [int] maximum mean intensity of an image before it is discared as too bright border: [int] apply a mask on the detections by removing all that are too close to the given image border (in pixels) neighborhood_size: [int] size of the neighbourhood for the maximum search (in pixels) intensity_threshold: [float] a threshold for cutting the detections which are too faint (0-255) flat_struct: [Flat struct] Structure containing the flat field. None by default. dark: [ndarray] Dark frame. None by default. mask: [ndarray] Mask image. None by default. Return: x2, y2, background, intensity, fwhm: [list of ndarrays] - x2: X axis coordinates of the star - y2: Y axis coordinates of the star - background: background intensity - intensity: intensity of the star - Gaussian Full width at half maximum (FWHM) of fitted stars """ # This will be returned if there was an error error_return = [[], [], [], [], [], []] # Load parameters from config if given if config: max_global_intensity = config.max_global_intensity border = config.border neighborhood_size = config.neighborhood_size intensity_threshold = config.intensity_threshold # Load the FF bin file ff = FFfile.read(ff_dir, ff_name) # If the FF file could not be read, skip star extraction if ff is None: return error_return # Apply the dark frame if dark is not None: ff.avepixel = Image.applyDark(ff.avepixel, dark) # Apply the flat if flat_struct is not None: ff.avepixel = Image.applyFlat(ff.avepixel, flat_struct) # Mask the FF file if mask is not None: ff = MaskImage.applyMask(ff, mask, ff_flag=True) # Calculate image mean and stddev global_mean = np.mean(ff.avepixel) # Check if the image is too bright and skip the image if global_mean > max_global_intensity: return error_return data = ff.avepixel.astype(np.float32) # Apply a mean filter to the image to reduce noise data = ndimage.filters.convolve(data, weights=np.full((2, 2), 1.0 / 4)) # Locate local maxima on the image data_max = filters.maximum_filter(data, neighborhood_size) maxima = (data == data_max) data_min = filters.minimum_filter(data, neighborhood_size) diff = ((data_max - data_min) > intensity_threshold) maxima[diff == 0] = 0 # Apply a border mask border_mask = np.ones_like(maxima) * 255 border_mask[:border, :] = 0 border_mask[-border:, :] = 0 border_mask[:, :border] = 0 border_mask[:, -border:] = 0 maxima = MaskImage.applyMask(maxima, border_mask, image=True) # Remove all detections close to the mask image if mask is not None: erosion_kernel = np.ones((5, 5), mask.img.dtype) mask_eroded = cv2.erode(mask.img, erosion_kernel, iterations=1) maxima = MaskImage.applyMask(maxima, mask_eroded, image=True) # Find and label the maxima labeled, num_objects = ndimage.label(maxima) # Skip the image if there are too many maxima to process if num_objects > config.max_stars: print('Too many candidate stars to process! {:d}/{:d}'.format( num_objects, config.max_stars)) return error_return # Find centres of mass of each labeled objects xy = np.array( ndimage.center_of_mass(data, labeled, range(1, num_objects + 1))) # Remove all detection on the border #xy = xy[np.where((xy[:, 1] > border) & (xy[:,1] < ff.ncols - border) & (xy[:,0] > border) & (xy[:,0] < ff.nrows - border))] # Unpack star coordinates y, x = np.hsplit(xy, 2) # # Plot stars before the PSF fit # plotStars(ff, x, y) # Fit a PSF to each star x2, y2, amplitude, intensity, sigma_y_fitted, sigma_x_fitted = fitPSF( ff, global_mean, x, y, config) # x2, y2, amplitude, intensity = list(x), list(y), [], [] # Skip PSF fit # # Plot stars after PSF fit filtering # plotStars(ff, x2, y2) # Compute FWHM from one dimensional sigma sigma_x_fitted = np.array(sigma_x_fitted) sigma_y_fitted = np.array(sigma_y_fitted) sigma_fitted = np.sqrt(sigma_x_fitted**2 + sigma_y_fitted**2) fwhm = 2.355 * sigma_fitted return ff_name, x2, y2, amplitude, intensity, fwhm
def getThresholdedStripe3DPoints(config, img_handle, frame_min, frame_max, rho, theta, mask, flat_struct, \ dark, stripe_width_factor=1.0, centroiding=False, point1=None, point2=None, debug=False): """ Threshold the image and get a list of pixel positions and frames of threshold passers. This function handles all input types of data. Arguments; config: [config object] configuration object (loaded from the .config file). img_handle: [FrameInterface instance] Object which has a common interface to various input files. frame_min: [int] First frame to process. frame_max: [int] Last frame to process. rho: [float] Line distance from the center in HT space (pixels). theta: [float] Angle in degrees in HT space. mask: [ndarray] Image mask. flat_struct: [Flat struct] Structure containing the flat field. None by default. dark: [ndarray] Dark frame. Keyword arguments: stripe_width_factor: [float] Multipler by which the default stripe width will be multiplied. Default is 1.0 centroiding: [bool] If True, the indices will be returned in the centroiding mode, which means that point1 and point2 arguments must be given. point1: [list] (x, y, frame) Of the first reference point of the detection. point2: [list] (x, y, frame) Of the second reference point of the detection. debug: [bool] If True, extra debug messages and plots will be shown. Return: xs, ys, zs: [tuple of lists] Indices of (x, y, frame) of threshold passers for every frame. """ # Get indices of stripe pixels around the line of the meteor img_h, img_w = img_handle.ff.maxpixel.shape stripe_indices = getStripeIndices(rho, theta, stripe_width_factor*config.stripe_width, img_h, img_w) # If centroiding should be done, prepare everything for cutting out parts of the image for photometry if centroiding: # Compute the unit vector which describes the motion of the meteor in the image domain point1 = np.array(point1) point2 = np.array(point2) motion_vect = point2[:2] - point1[:2] motion_vect_unit = vectNorm(motion_vect) # Get coordinates of 2 points that describe the line x1, y1, z1 = point1 x2, y2, z2 = point2 # Compute the average angular velocity in px per frame ang_vel = np.sqrt((x2 - x1)**2 + (y2 - y1)**2)/(z2 - z1) # Compute the vector describing the length and direction of the meteor per frame motion_vect = ang_vel*motion_vect_unit # If the FF files is given, extract the points from FF after threshold if img_handle.input_type == 'ff': # Threshold the FF file img_thres = Image.thresholdFF(img_handle.ff, config.k1_det, config.j1_det, mask=mask, \ mask_ave_bright=False) # Extract the thresholded image by min and max frames from FF file img = selectFFFrames(np.copy(img_thres), img_handle.ff, frame_min, frame_max) # Remove lonely pixels img = morph.clean(img) # Extract the stripe from the thresholded image stripe = np.zeros(img.shape, img.dtype) stripe[stripe_indices] = img[stripe_indices] # Show stripe # show2("stripe", stripe*255) # Show 3D could # show3DCloud(ff, stripe) # Get stripe positions (x, y, frame) stripe_positions = stripe.nonzero() xs = stripe_positions[1] ys = stripe_positions[0] zs = img_handle.ff.maxframe[stripe_positions] return xs, ys, zs # If video frames are available, extract indices on all frames in the given range else: xs_array = [] ys_array = [] zs_array = [] # Go through all frames in the frame range for fr in range(frame_min, frame_max + 1): # Break the loop if outside frame size if fr == (img_handle.total_frames - 1): break # Set the frame number img_handle.setFrame(fr) # Load the frame fr_img = img_handle.loadFrame() # Apply the dark frame if dark is not None: fr_img = Image.applyDark(fr_img, dark) # Apply the flat to frame if flat_struct is not None: fr_img = Image.applyFlat(fr_img, flat_struct) # Mask the image fr_img = MaskImage.applyMask(fr_img, mask) # Threshold the frame img_thres = Image.thresholdImg(fr_img, img_handle.ff.avepixel, img_handle.ff.stdpixel, \ config.k1_det, config.j1_det, mask=mask, mask_ave_bright=False) # Remove lonely pixels img_thres = morph.clean(img_thres) # Extract the stripe from the thresholded image stripe = np.zeros(img_thres.shape, img_thres.dtype) stripe[stripe_indices] = img_thres[stripe_indices] # Include more pixels for centroiding and photometry and mask out per frame pixels if centroiding: # Dilate the pixels in the stripe twice, to include more pixels for photometry stripe = morph.dilate(stripe) stripe = morph.dilate(stripe) # Get indices of the stripe that is perpendicular to the meteor, and whose thickness is the # length of the meteor on this particular frame - this is called stripe_indices_motion # Compute the previous, current, and the next linear model position of the meteor on the # image model_pos_prev = point1[:2] + (fr - 1 - z1)*motion_vect model_pos = point1[:2] + (fr - z1)*motion_vect model_pos_next = point1[:2] + (fr + 1 - z1)*motion_vect # Get the rho, theta of the line perpendicular to the meteor line x_inters, y_inters = model_pos # Check if the previous, current or the next centroids are outside bounds, and if so, skip the # frame if (not checkCentroidBounds(model_pos_prev, img_w, img_h)) or \ (not checkCentroidBounds(model_pos, img_w, img_h)) or \ (not checkCentroidBounds(model_pos_next, img_w, img_h)): continue # Get parameters of the perpendicular line to the meteor line rho2, theta2 = htLinePerpendicular(rho, theta, x_inters, y_inters, img_h, img_w) # Compute the image indices of this position which will be the intersection with the stripe # The width of the line will be 2x the angular velocity stripe_length = 6*ang_vel if stripe_length < stripe_width_factor*config.stripe_width: stripe_length = stripe_width_factor*config.stripe_width stripe_indices_motion = getStripeIndices(rho2, theta2, stripe_length, img_h, img_w) # Mark only those parts which overlap both lines, which effectively creates a mask for # photometry an centroiding, excluding other influences stripe_new = np.zeros_like(stripe) stripe_new[stripe_indices_motion] = stripe[stripe_indices_motion] stripe = stripe_new if debug: # Show the extracted stripe img_stripe = np.zeros_like(stripe) img_stripe[stripe_indices] = 1 final_stripe = np.zeros_like(stripe) final_stripe[stripe_indices_motion] = img_stripe[stripe_indices_motion] plt.imshow(final_stripe) plt.show() if debug and centroiding: print(fr) print('mean stdpixel3:', np.mean(img_handle.ff.stdpixel)) print('mean avepixel3:', np.mean(img_handle.ff.avepixel)) print('mean frame:', np.mean(fr_img)) fig, (ax1, ax2) = plt.subplots(nrows=2, sharex=True, sharey=True) fr_img_noavg = Image.applyDark(fr_img, img_handle.ff.avepixel) #fr_img_noavg = fr_img # Auto levels min_lvl = np.percentile(fr_img_noavg[2:, :], 1) max_lvl = np.percentile(fr_img_noavg[2:, :], 99.0) # Adjust levels fr_img_autolevel = Image.adjustLevels(fr_img_noavg, min_lvl, 1.0, max_lvl) ax1.imshow(stripe, cmap='gray') ax2.imshow(fr_img_autolevel, cmap='gray') plt.show() pass # Get stripe positions (x, y, frame) stripe_positions = stripe.nonzero() xs = stripe_positions[1] ys = stripe_positions[0] zs = np.zeros_like(xs) + fr # Add the points to the list xs_array.append(xs) ys_array.append(ys) zs_array.append(zs) if debug: print('---') print(stripe.nonzero()) print(xs, ys, zs) if len(xs_array) > 0: # Flatten the arrays xs_array = np.concatenate(xs_array) ys_array = np.concatenate(ys_array) zs_array = np.concatenate(zs_array) else: xs_array = np.array(xs_array) ys_array = np.array(ys_array) zs_array = np.array(zs_array) return xs_array, ys_array, zs_array
def extractStars(ff_dir, ff_name, config=None, max_global_intensity=150, border=10, neighborhood_size=10, intensity_threshold=5, flat_struct=None, dark=None, mask=None): """ Extracts stars on a given FF bin by searching for local maxima and applying PSF fit for star confirmation. Source of one part of the code: http://stackoverflow.com/questions/9111711/get-coordinates-of-local-maxima-in-2d-array-above-certain-value Arguments: ff: [ff bin struct] FF bin file loaded in the FF bin structure config: [config object] configuration object (loaded from the .config file) max_global_intensity: [int] maximum mean intensity of an image before it is discared as too bright border: [int] apply a mask on the detections by removing all that are too close to the given image border (in pixels) neighborhood_size: [int] size of the neighbourhood for the maximum search (in pixels) intensity_threshold: [float] a threshold for cutting the detections which are too faint (0-255) flat_struct: [Flat struct] Structure containing the flat field. None by default. dark: [ndarray] Dark frame. None by default. mask: [ndarray] Mask image. None by default. Return: x2, y2, background, intensity, sigma_fitted: [list of ndarrays] - x2: X axis coordinates of the star - y2: Y axis coordinates of the star - background: background intensity - intensity: intensity of the star - Gaussian stddev of fitted stars """ # This will be returned if there was an error error_return = [[], [], [], []] # Load parameters from config if given if config: max_global_intensity = config.max_global_intensity border = config.border neighborhood_size = config.neighborhood_size intensity_threshold = config.intensity_threshold # Load the FF bin file ff = FFfile.read(ff_dir, ff_name) # If the FF file could not be read, skip star extraction if ff is None: return error_return # Apply the dark frame if dark is not None: ff.avepixel = Image.applyDark(ff.avepixel, dark) # Apply the flat if flat_struct is not None: ff.avepixel = Image.applyFlat(ff.avepixel, flat_struct) # Mask the FF file if mask is not None: ff = MaskImage.applyMask(ff, mask, ff_flag=True) # Calculate image mean and stddev global_mean = np.mean(ff.avepixel) # Check if the image is too bright and skip the image if global_mean > max_global_intensity: return error_return data = ff.avepixel.astype(np.float32) # Apply a mean filter to the image to reduce noise data = ndimage.filters.convolve(data, weights=np.full((2, 2), 1.0/4)) # Locate local maxima on the image data_max = filters.maximum_filter(data, neighborhood_size) maxima = (data == data_max) data_min = filters.minimum_filter(data, neighborhood_size) diff = ((data_max - data_min) > intensity_threshold) maxima[diff == 0] = 0 # Apply a border mask border_mask = np.ones_like(maxima)*255 border_mask[:border,:] = 0 border_mask[-border:,:] = 0 border_mask[:,:border] = 0 border_mask[:,-border:] = 0 maxima = MaskImage.applyMask(maxima, border_mask, image=True) # Find and label the maxima labeled, num_objects = ndimage.label(maxima) # Skip the image if there are too many maxima to process if num_objects > config.max_stars: print('Too many candidate stars to process! {:d}/{:d}'.format(num_objects, config.max_stars)) return error_return # Find centres of mass of each labeled objects xy = np.array(ndimage.center_of_mass(data, labeled, range(1, num_objects+1))) # Remove all detection on the border #xy = xy[np.where((xy[:, 1] > border) & (xy[:,1] < ff.ncols - border) & (xy[:,0] > border) & (xy[:,0] < ff.nrows - border))] # Unpack star coordinates y, x = np.hsplit(xy, 2) # # Plot stars before the PSF fit # plotStars(ff, x, y) # Fit a PSF to each star x2, y2, amplitude, intensity, sigma_y_fitted, sigma_x_fitted = fitPSF(ff, global_mean, x, y, config) # x2, y2, amplitude, intensity = list(x), list(y), [], [] # Skip PSF fit # # Plot stars after PSF fit filtering # plotStars(ff, x2, y2) # Compute one dimensional sigma sigma_x_fitted = np.array(sigma_x_fitted) sigma_y_fitted = np.array(sigma_y_fitted) sigma_fitted = np.sqrt(sigma_x_fitted**2 + sigma_y_fitted**2) return ff_name, x2, y2, amplitude, intensity, sigma_fitted