def test_Allignment(i): imagePath = os.path.join('.', 'img') outrgbPath = os.path.join('.', 'data', 'rgb', '{:04d}.png'.format(i)) outcirPath = os.path.join('.', 'data', 'cir', '{:04d}.png'.format(i)) imageNames = glob.glob( os.path.join(imagePath, 'IMG_{:04d}_*.tif'.format(i))) panelNames = glob.glob(os.path.join(imagePath, 'IMG_0000_*.tif')) print(imageNames) if len(panelNames) == 0: panelCap = None else: panelCap = cap.Capture.from_filelist(panelNames) capture = cap.Capture.from_filelist(imageNames) allignmat, havePrev = ReadAllignmentMatrix(".") if havePrev == False: allignmat = GetAllignmentMatrix(capture) SaveAllignmentMatrix("a_mat_{}.txt", allignmat) im_aligned = AllignImage(allignmat, capture) print(capture.band_names()) rgb_band_indices = [ capture.band_names().index('Red'), capture.band_names().index('Green'), capture.band_names().index('Blue') ] cir_band_indices = [ capture.band_names().index('NIR'), capture.band_names().index('Red'), capture.band_names().index('Green') ] im_display = np.zeros( (im_aligned.shape[0], im_aligned.shape[1], im_aligned.shape[2]), dtype=np.float32) im_min = np.percentile(im_aligned[:, :, rgb_band_indices].flatten(), 0.5) # modify these percentiles to adjust contrast im_max = np.percentile( im_aligned[:, :, rgb_band_indices].flatten(), 99.5) # for many images, 0.5 and 99.5 are good values for i in rgb_band_indices: im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i], im_min, im_max) rgb = im_display[:, :, rgb_band_indices] for i in cir_band_indices: im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i]) cir = im_display[:, :, cir_band_indices] cv2.imshow("rgb", rgb) cv2.imshow("cir", cir) print(np.max(rgb)) print(np.min(rgb)) rgb = cv2.normalize(rgb, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC3) cir = cv2.normalize(cir, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC3) cv2.imwrite(outrgbPath, rgb) cv2.imwrite(outcirPath, cir) cv2.waitKey(10) return
def save_capture_as_rgb(self, outfilename, gamma=1.4, downsample=1, white_balance='norm', hist_min_percent=0.5, hist_max_percent=99.5, sharpen=True): rgb_band_indices = [2, 1, 0] if self.__aligned_capture is None: raise RuntimeError( "call Capture.create_aligned_capture prior to saving as RGB") im_display = np.zeros( (self.__aligned_capture.shape[0], self.__aligned_capture.shape[1], self.__aligned_capture.shape[2]), dtype=np.float32) im_min = np.percentile( self.__aligned_capture[:, :, rgb_band_indices].flatten(), hist_min_percent) # modify these percentiles to adjust contrast im_max = np.percentile( self.__aligned_capture[:, :, rgb_band_indices].flatten(), hist_max_percent) # for many images, 0.5 and 99.5 are good values for i in rgb_band_indices: # for rgb true color, we usually want to use the same min and max scaling across the 3 bands to # maintain the "white balance" of the calibrated image if white_balance == 'norm': im_display[:, :, i] = imageutils.normalize( self.__aligned_capture[:, :, i], im_min, im_max) else: im_display[:, :, i] = imageutils.normalize( self.__aligned_capture[:, :, i]) rgb = im_display[:, :, rgb_band_indices] rgb = cv2.resize(rgb, None, fx=1 / downsample, fy=1 / downsample, interpolation=cv2.INTER_AREA) if sharpen: gaussian_rgb = cv2.GaussianBlur(rgb, (9, 9), 10.0) gaussian_rgb[gaussian_rgb < 0] = 0 gaussian_rgb[gaussian_rgb > 1] = 1 unsharp_rgb = cv2.addWeighted(rgb, 1.5, gaussian_rgb, -0.5, 0) unsharp_rgb[unsharp_rgb < 0] = 0 unsharp_rgb[unsharp_rgb > 1] = 1 else: unsharp_rgb = rgb # Apply a gamma correction to make the render appear closer to what our eyes would see if gamma != 0: gamma_corr_rgb = unsharp_rgb**(1.0 / gamma) imageio.imwrite(outfilename, (255 * gamma_corr_rgb).astype('uint8')) else: imageio.imwrite(outfilename, (255 * unsharp_rgb).astype('uint8'))
def save_capture_as_rgb(self, out_file_name, gamma=1.4, downsample=1, white_balance='norm', hist_min_percent=0.5, hist_max_percent=99.5, sharpen=True, rgb_band_indices=(2, 1, 0)): """ Output the Images in the Capture object as RGB. :param out_file_name: str system file path :param gamma: float gamma correction :param downsample: int downsample for cv2.resize() :param white_balance: str 'norm' to normalize across bands using hist_min_percent and hist_max_percent. Else this parameter is ignored. :param hist_min_percent: float for min histogram stretch :param hist_max_percent: float for max histogram stretch :param sharpen: boolean :param rgb_band_indices: List band order """ if self.__aligned_capture is None: raise RuntimeError("Call Capture.create_aligned_capture() prior to saving as RGB.") im_display = np.zeros( (self.__aligned_capture.shape[0], self.__aligned_capture.shape[1], self.__aligned_capture.shape[2]), dtype=np.float32) # modify these percentiles to adjust contrast. for many images, 0.5 and 99.5 are good values im_min = np.percentile(self.__aligned_capture[:, :, rgb_band_indices].flatten(), hist_min_percent) im_max = np.percentile(self.__aligned_capture[:, :, rgb_band_indices].flatten(), hist_max_percent) for i in rgb_band_indices: # for rgb true color, we usually want to use the same min and max scaling across the 3 bands to # maintain the "white balance" of the calibrated image if white_balance == 'norm': im_display[:, :, i] = imageutils.normalize(self.__aligned_capture[:, :, i], im_min, im_max) else: im_display[:, :, i] = imageutils.normalize(self.__aligned_capture[:, :, i]) rgb = im_display[:, :, rgb_band_indices] rgb = cv2.resize(rgb, None, fx=1 / downsample, fy=1 / downsample, interpolation=cv2.INTER_AREA) if sharpen: gaussian_rgb = cv2.GaussianBlur(rgb, (9, 9), 10.0) gaussian_rgb[gaussian_rgb < 0] = 0 gaussian_rgb[gaussian_rgb > 1] = 1 unsharp_rgb = cv2.addWeighted(rgb, 1.5, gaussian_rgb, -0.5, 0) unsharp_rgb[unsharp_rgb < 0] = 0 unsharp_rgb[unsharp_rgb > 1] = 1 else: unsharp_rgb = rgb # Apply a gamma correction to make the render appear closer to what our eyes would see if gamma != 0: gamma_corr_rgb = unsharp_rgb ** (1.0 / gamma) imageio.imwrite(out_file_name, (255 * gamma_corr_rgb).astype('uint8')) else: imageio.imwrite(out_file_name, (255 * unsharp_rgb).astype('uint8'))
def proc_stack(i, warp_matrices, bndFolders, panel_irradiance): i.compute_reflectance(panel_irradiance) #i.plot_undistorted_reflectance(panel_irradiance) cropped_dimensions, edges = imageutils.find_crop_bounds(i, warp_matrices) im_aligned = imageutils.aligned_capture(i, warp_matrices, cv2.MOTION_HOMOGRAPHY, cropped_dimensions, None, img_type="reflectance") im_display = np.zeros((im_aligned.shape[0],im_aligned.shape[1],5), dtype=np.float32) rows, cols, bands = im_display.shape driver = gdal.GetDriverByName('GTiff') im = i.images[1].path hd, nm = os.path.split(im[:-6]) filename = os.path.join(reflFolder, nm+'.tif') #blue,green,red,nir,redEdge # outRaster = driver.Create(filename, cols, rows, 5, gdal.GDT_Byte) normalize = False # Output a 'stack' in the same band order as RedEdge/Alutm # Blue,Green,Red,NIR,RedEdge[,Thermal] # NOTE: NIR and RedEdge are not in wavelength order! i.compute_reflectance(panel_irradiance+[0]) for i in range(0,5): outband = outRaster.GetRasterBand(i+1) if normalize: outband.WriteArray(imageutils.normalize(im_aligned[:,:,i])*65535) else: outdata = im_aligned[:,:,i] outdata[outdata<0] = 0 outdata[outdata>1] = 1 outband.WriteArray(outdata*65535) outband.FlushCache() if im_aligned.shape[2] == 6: outband = outRaster.GetRasterBand(6) outdata = im_aligned[:,:,5] * 100 # scale to centi-C to fit into uint16 outdata[outdata<0] = 0 outdata[outdata>65535] = 65535 outband.WriteArray(outdata) outband.FlushCache() outRaster = None cmd = ["exiftool", "-tagsFromFile", im, "-file:all", "-iptc:all", "-exif:all", "-xmp", "-Composite:all", filename, "-overwrite_original"] call(cmd)
def proc_imgs(i, warp_matrices, bndFolders, panel_irradiance, normalize=None): # for i in imgset.captures: i.compute_reflectance(panel_irradiance) #i.plot_undistorted_reflectance(panel_irradiance) cropped_dimensions, edges = imageutils.find_crop_bounds(i, warp_matrices) im_aligned = imageutils.aligned_capture(i, warp_matrices, cv2.MOTION_HOMOGRAPHY, cropped_dimensions, None, img_type="reflectance") im_display = np.zeros((im_aligned.shape[0],im_aligned.shape[1],5), dtype=np.float32 ) for iM in range(0,im_aligned.shape[2]): im_display[:,:,iM] = imageutils.normalize(im_aligned[:,:,iM])*65535 for k in range(0,im_display.shape[2]): im = i.images[k] hd, nm = os.path.split(im.path) outdata = im_aligned[:,:,i] outdata[outdata<0] = 0 outdata[outdata>1] = 1 outfile = os.path.join(bndFolders[k], nm) imageio.imwrite(outfile, outdata) cmd = ["exiftool", "-tagsFromFile", im.path, "-file:all", "-iptc:all", "-exif:all", "-xmp", "-Composite:all", outfile, "-overwrite_original"] call(cmd)
def save_thermal_over_rgb(self, outfilename, figsize=(30, 23), lw_index=None, hist_min_percent=0.2, hist_max_percent=99.8): if self.__aligned_capture is None: raise RuntimeError( "call Capture.create_aligned_capture prior to saving as RGB") # by default we don't mask the thermal, since it's native resolution is much lower than the MS if lw_index is None: lw_index = self.lw_indices()[0] masked_thermal = self.__aligned_capture[:, :, lw_index] im_display = np.zeros((self.__aligned_capture.shape[0], self.__aligned_capture.shape[1], 3), dtype=np.float32) rgb_band_indices = [ self.band_names_lower().index('red'), self.band_names_lower().index('green'), self.band_names_lower().index('blue') ] # for rgb true color, we usually want to use the same min and max scaling across the 3 bands to # maintain the "white balance" of the calibrated image im_min = np.percentile( self.__aligned_capture[:, :, rgb_band_indices].flatten(), hist_min_percent) # modify these percentiles to adjust contrast im_max = np.percentile( self.__aligned_capture[:, :, rgb_band_indices].flatten(), hist_max_percent) # for many images, 0.5 and 99.5 are good values for dst_band, src_band in enumerate(rgb_band_indices): im_display[:, :, dst_band] = imageutils.normalize( self.__aligned_capture[:, :, src_band], im_min, im_max) # Compute a histogram min_display_therm = np.percentile(masked_thermal, hist_min_percent) max_display_therm = np.percentile(masked_thermal, hist_max_percent) fig, _ = plotutils.plot_overlay_withcolorbar( im_display, masked_thermal, figsize=figsize, title='Temperature over True Color', vmin=min_display_therm, vmax=max_display_therm, overlay_alpha=0.25, overlay_colormap='jet', overlay_steps=16, display_contours=True, contour_steps=16, contour_alpha=.4, contour_fmt="%.0fC", show=False) fig.savefig(outfilename)
def main(imagePath, warp_matrices, alignment_pairs, panel_irradiance): import micasense.capture as capture for i in range(0,201): imageRoot = "IMG_%04i" % i outputRoot = imagePath.replace('Imagery\\','').replace('\\','_') + imageRoot imageSet = os.path.join(imagePath,imageRoot+'_*.tif')re imageNames = glob.glob(imageSet) if not len(imageNames): continue #skip # try: imgCap = capture.Capture.from_filelist(imageNames) imgCap.compute_reflectance(panel_irradiance) dist_coeffs = [] cam_mats = [] for i,img in enumerate(imgCap.images): dist_coeffs.append(img.cv2_distortion_coeff()) cam_mats.append(img.cv2_camera_matrix()) cropped_dimensions = imageutils.find_crop_bounds(imgCap.images[0].size(), warp_matrices, dist_coeffs, cam_mats) im_aligned = imageutils.aligned_capture(warp_matrices, alignment_pairs, cropped_dimensions) im_display = np.zeros((im_aligned.shape[0],im_aligned.shape[1],5), dtype=np.float32 ) for i in range(0,im_aligned.shape[2]): im_display[:,:,i] = imageutils.normalize(im_aligned[:,:,i]) rgb = im_display[:,:,[2,1,0]] cir = im_display[:,:,[3,2,1]] gaussian_rgb = cv2.GaussianBlur(rgb, (9,9), 10.0) gaussian_rgb[gaussian_rgb<0] = 0 gaussian_rgb[gaussian_rgb>1] = 1 unsharp_rgb = cv2.addWeighted(rgb, 1.5, gaussian_rgb, -0.5, 0) unsharp_rgb[unsharp_rgb<0] = 0 unsharp_rgb[unsharp_rgb>1] = 1 gamma = 1.4 gamma_corr_rgb = unsharp_rgb**(1.0/gamma) # Output imtype = '.jpg' # or 'jpg' imageio.imwrite(os.path.join('.','Output','rgb',outputRoot+imtype), (255*gamma_corr_rgb).astype('uint8')) imageio.imwrite(os.path.join('.','Output','cir',outputRoot+imtype), (255*cir).astype('uint8')) from osgeo import gdal, gdal_array rows, cols, bands = im_display.shape driver = gdal.GetDriverByName('GTiff') outRaster = driver.Create(os.path.join('.','Output','5band',outputRoot+".tiff"), cols, rows, bands, gdal.GDT_Float32) for i in range(0,bands): outband = outRaster.GetRasterBand(i+1) outband.WriteArray(im_aligned[:,:,i]) outband.FlushCache() outRaster = None im_aligned = None print ("processed " + imageSet)
def proc_imgs_comp(i, warp_matrices, bndFolders, panel_irradiance): i.compute_reflectance(panel_irradiance) #i.plot_undistorted_reflectance(panel_irradiance) cropped_dimensions, edges = imageutils.find_crop_bounds(i, warp_matrices) im_aligned = imageutils.aligned_capture(i, warp_matrices, cv2.MOTION_HOMOGRAPHY, cropped_dimensions, None, img_type="reflectance") im_display = np.zeros((im_aligned.shape[0],im_aligned.shape[1],5), dtype=np.float32 ) for iM in range(0,im_aligned.shape[2]): im_display[:,:,iM] = imageutils.normalize(im_aligned[:,:,iM]) rgb = im_display[:,:,[2,1,0]] #cir = im_display[:,:,[3,2,1]] RRENir = im_display[:,:,[4,3,2]] imoot = [rgb, RRENir] imtags = ["RGB.tif", "RRENir.tif"] im = i.images[1] hd, nm = os.path.split(im.path[:-5]) for ind, k in enumerate(bndFolders): img8 = bytescale(imoot[ind]) outfile = os.path.join(k, nm+imtags[ind]) imageio.imwrite(outfile, img8) cmd = ["exiftool", "-tagsFromFile", im.path, "-file:all", "-iptc:all", "-exif:all", "-xmp", "-Composite:all", outfile, "-overwrite_original"] call(cmd)
def correction(image_path, image_name, panel_path, panel_name): import micasense.capture as capture get_ipython().run_line_magic('load_ext', 'autoreload') get_ipython().run_line_magic('autoreload', '2') # 輸入照片位置 get_ipython().run_line_magic('matplotlib', 'inline') panelNames = None # This is an altum image with RigRelatives and a thermal band imageNames = glob.glob(os.path.join(image_path, image_name + '_*.tif')) panelNames = glob.glob(os.path.join(panel_path, panel_name + '_*.tif')) if panelNames is not None: panelCap = capture.Capture.from_filelist(panelNames) else: panelCap = None capture = capture.Capture.from_filelist(imageNames) for img in capture.images: if img.rig_relatives is None: raise ValueError( "Images must have RigRelatives tags set which requires updated firmware and calibration. See the links in text above" ) if panelCap is not None: if panelCap.panel_albedo() is not None: panel_reflectance_by_band = panelCap.panel_albedo() else: # RedEdge band_index order panel_reflectance_by_band = [0.67, 0.69, 0.68, 0.61, 0.67] panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band) img_type = "reflectance" capture.plot_undistorted_reflectance(panel_irradiance) else: if False: # capture.dls_present(): img_type = 'reflectance' capture.plot_undistorted_reflectance(capture.dls_irradiance()) else: img_type = "radiance" capture.plot_undistorted_radiance() # 相片對齊 warp_mode = cv2.MOTION_HOMOGRAPHY warp_matrices = capture.get_warp_matrices() cropped_dimensions, edges = imageutils.find_crop_bounds( capture, warp_matrices) im_aligned = imageutils.aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, None, img_type=img_type) print("warp_matrices={}".format(warp_matrices)) rgb_band_indices = [2, 1, 0] # Create an empty normalized stack for viewing im_display = np.zeros( (im_aligned.shape[0], im_aligned.shape[1], capture.num_bands + 1), dtype=np.float32) # modify with these percentilse to adjust contrast im_min = np.percentile(im_aligned[:, :, 0:2].flatten(), 0.1) # for many images, 0.5 and 99.5 are good values im_max = np.percentile(im_aligned[:, :, 0:2].flatten(), 99.9) for i in range(0, im_aligned.shape[2]): if img_type == 'reflectance': # for reflectance images we maintain white-balance by applying the same display scaling to all bands im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i], im_min, im_max) elif img_type == 'radiance': # for radiance images we do an auto white balance since we don't know the input light spectrum by # stretching each display band histogram to it's own min and max im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i]) rgb = im_display[:, :, rgb_band_indices] # 合成出rgb圖 # Create an enhanced version of the RGB render using an unsharp mask gaussian_rgb = cv2.GaussianBlur(rgb, (9, 9), 10.0) gaussian_rgb[gaussian_rgb < 0] = 0 gaussian_rgb[gaussian_rgb > 1] = 1 unsharp_rgb = cv2.addWeighted(rgb, 1.5, gaussian_rgb, -0.5, 0) unsharp_rgb[unsharp_rgb < 0] = 0 unsharp_rgb[unsharp_rgb > 1] = 1 # Apply a gamma correction to make the render appear closer to what our eyes would see gamma = 1.2 gamma_corr_rgb = unsharp_rgb**(1.0 / gamma) plt.imshow(gamma_corr_rgb, aspect='equal') plt.axis('off') plt.show() # 匯出rgb圖 imtype = 'png' # or 'jpg' imageio.imwrite(image_name + '_rgb.' + imtype, (255 * gamma_corr_rgb).astype('uint8')) blue_band = capture.band_names_lower().index('blue') green_band = capture.band_names_lower().index('green') red_band = capture.band_names_lower().index('red') nir_band = capture.band_names_lower().index('nir') rededge_band = capture.band_names_lower().index('red edge') blue = im_aligned[:, :, blue_band] blue = blue.astype('float64') np.save(image_name + '_blue', blue) green = im_aligned[:, :, green_band] green = green.astype('float64') np.save(image_name + '_green', green) red = im_aligned[:, :, red_band] red = red.astype('float64') np.save(image_name + '_red', red) rededge = im_aligned[:, :, rededge_band] red = rededge.astype('float64') np.save(image_name + '_rededge', rededge) nir = im_aligned[:, :, nir_band] nir = nir.astype('float64') np.save(image_name + '_nir', nir) return print("all bands npy file save") get_ipython().run_line_magic('load_ext', 'autoreload') get_ipython().run_line_magic('autoreload', '2') # 輸入照片位置 get_ipython().run_line_magic('matplotlib', 'inline') panelNames = None # This is an altum image with RigRelatives and a thermal band imagePath = os.path.join('.', 'data') imageNames = glob.glob(os.path.join(imagePath, 'IMG_0134_*.tif')) panelNames = glob.glob(os.path.join(imagePath, 'IMG_0003_*.tif')) if panelNames is not None: panelCap = capture.Capture.from_filelist(panelNames) else: panelCap = None capture = capture.Capture.from_filelist(imageNames) for img in capture.images: if img.rig_relatives is None: raise ValueError( "Images must have RigRelatives tags set which requires updated firmware and calibration. See the links in text above" ) if panelCap is not None: if panelCap.panel_albedo() is not None: panel_reflectance_by_band = panelCap.panel_albedo() else: # RedEdge band_index order panel_reflectance_by_band = [0.67, 0.69, 0.68, 0.61, 0.67] panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band) img_type = "reflectance" capture.plot_undistorted_reflectance(panel_irradiance) else: if False: # capture.dls_present(): img_type = 'reflectance' capture.plot_undistorted_reflectance(capture.dls_irradiance()) else: img_type = "radiance" capture.plot_undistorted_radiance() # 相片對齊 warp_mode = cv2.MOTION_HOMOGRAPHY warp_matrices = capture.get_warp_matrices() cropped_dimensions, edges = imageutils.find_crop_bounds( capture, warp_matrices) im_aligned = imageutils.aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, None, img_type=img_type) print("warp_matrices={}".format(warp_matrices)) rgb_band_indices = [2, 1, 0] # Create an empty normalized stack for viewing im_display = np.zeros( (im_aligned.shape[0], im_aligned.shape[1], capture.num_bands + 1), dtype=np.float32) # modify with these percentilse to adjust contrast im_min = np.percentile(im_aligned[:, :, 0:2].flatten(), 0.1) # for many images, 0.5 and 99.5 are good values im_max = np.percentile(im_aligned[:, :, 0:2].flatten(), 99.9) for i in range(0, im_aligned.shape[2]): if img_type == 'reflectance': # for reflectance images we maintain white-balance by applying the same display scaling to all bands im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i], im_min, im_max) elif img_type == 'radiance': # for radiance images we do an auto white balance since we don't know the input light spectrum by # stretching each display band histogram to it's own min and max im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i]) rgb = im_display[:, :, rgb_band_indices] # 合成出rgb圖 # Create an enhanced version of the RGB render using an unsharp mask gaussian_rgb = cv2.GaussianBlur(rgb, (9, 9), 10.0) gaussian_rgb[gaussian_rgb < 0] = 0 gaussian_rgb[gaussian_rgb > 1] = 1 unsharp_rgb = cv2.addWeighted(rgb, 1.5, gaussian_rgb, -0.5, 0) unsharp_rgb[unsharp_rgb < 0] = 0 unsharp_rgb[unsharp_rgb > 1] = 1 # Apply a gamma correction to make the render appear closer to what our eyes would see gamma = 1.2 gamma_corr_rgb = unsharp_rgb**(1.0 / gamma) plt.imshow(gamma_corr_rgb, aspect='equal') plt.axis('off') plt.show() # 匯出rgb圖 imtype = 'png' # or 'jpg' imageio.imwrite('rgb.' + imtype, (255 * gamma_corr_rgb).astype('uint8')) blue_band = capture.band_names_lower().index('blue') green_band = capture.band_names_lower().index('green') red_band = capture.band_names_lower().index('red') nir_band = capture.band_names_lower().index('nir') rededge_band = capture.band_names_lower().index('red edge') blue = im_aligned[:, :, blue_band] blue = blue.astype('float64') np.save('blue', blue) green = im_aligned[:, :, green_band] green = green.astype('float64') np.save('green', green) red = im_aligned[:, :, red_band] red = red.astype('float64') np.save('red', red) rededge = im_aligned[:, :, rededge_band] red = rededge.astype('float64') np.save('rededge', rededge) nir = im_aligned[:, :, nir_band] nir = nir.astype('float64') np.save('nir', nir)
def align_template(imAl, mx, reflFolder, ref_ind=rf): warp_matrices, alignment_pairs = imageutils.align_capture(imAl, ref_index=ref_ind, warp_mode=cv2.MOTION_HOMOGRAPHY, max_iterations=mx) for x,mat in enumerate(warp_matrices): print("Band {}:\n{}".format(x,mat)) # cropped_dimensions is of the form: # (first column with overlapping pixels present in all images, # first row with overlapping pixels present in all images, # number of columns with overlapping pixels in all images, # number of rows with overlapping pixels in all images ) dist_coeffs = [] cam_mats = [] # create lists of the distortion coefficients and camera matricies for i,img in enumerate(imAl.images): dist_coeffs.append(img.cv2_distortion_coeff()) cam_mats.append(img.cv2_camera_matrix()) warp_mode = cv2.MOTION_HOMOGRAPHY #alignment_pairs[0]['warp_mode'] match_index = alignment_pairs[0]['ref_index'] cropped_dimensions, edges = imageutils.find_crop_bounds(imAl, warp_matrices, warp_mode=cv2.MOTION_HOMOGRAPHY) # capture, warp_matrices, cv2.MOTION_HOMOGRAPHY, cropped_dimensions, None, img_type="reflectance", im_aligned = imageutils.aligned_capture(imAl, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type="reflectance") im_display = np.zeros((im_aligned.shape[0],im_aligned.shape[1],5), dtype=np.float32 ) for iM in range(0,im_aligned.shape[2]): im_display[:,:,iM] = imageutils.normalize(im_aligned[:,:,iM]) rgb = im_display[:,:,[2,1,0]] cir = im_display[:,:,[3,2,1]] grRE = im_display[:,:,[4,2,1]] if args.plts == True: fig, axes = plt.subplots(1, 3, figsize=(16,16)) plt.title("Red-Green-Blue Composite") axes[0].imshow(rgb) plt.title("Color Infrared (CIR) Composite") axes[1].imshow(cir) plt.title("Red edge-Green-Red (ReGR) Composite") axes[2].imshow(grRE) plt.show() prevList = [rgb, cir, grRE] nmList = ['rgb.jpg', 'cir.jpg', 'grRE.jpg'] names = [os.path.join(reflFolder, pv) for pv in nmList] for ind, p in enumerate(prevList): img8 = bytescale(p) imageio.imwrite(names[ind], img8) return warp_matrices, alignment_pairs#, dist_coeffs, cam_mats, cropped_dimensions
def main(img_dir, out_dir, alt_thresh, ncores, start_count, scaling, irradiance, subset, layer, resolution): # Create output dir it doesn't exist yet if not os.path.exists(out_dir): os.makedirs(out_dir) # Load all images as imageset imgset = imageset.ImageSet.from_directory(img_dir) meta_list = imgset.as_nested_lists() # Make feature collection of image centers and write it to tmp file point_list = [capture_to_point(c) for c in imgset.captures] feature_list = [{ 'type': 'Feature', 'properties': {}, 'geometry': mapping(x) } for x in point_list] fc = {'type': 'FeatureCollection', 'features': feature_list} ########################### #### Optionally cut a spatial subset of the images ########################## if subset == 'interactive': # Write feature collection to tmp file, to make it accessible to the flask app # without messing up with the session context fc_tmp_file = os.path.join(tempfile.gettempdir(), 'micamac_fc.geojson') with open(fc_tmp_file, 'w') as dst: json.dump(fc, dst) # Select spatial subset interactively (available as feature in POLYGONS[0]) app.run(debug=False, host='0.0.0.0') # Check which images intersect with the user defined polygon (list of booleans) poly_shape = shape(POLYGONS[0]['geometry']) in_polygon = [x.intersects(poly_shape) for x in point_list] print('Centroid of drawn polygon: %s' % poly_shape.centroid.wkt) elif subset is None: in_polygon = [True for x in point_list] elif os.path.exists(subset): with fiona.open(subset, layer) as src: poly_shape = shape(src[0]['geometry']) in_polygon = [x.intersects(poly_shape) for x in point_list] print('Centroid of supplied polygon: %s' % poly_shape.centroid.wkt) else: raise ValueError( '--subset must be interactive, the path to an OGR file or left empty' ) ################################## ### Threshold on altitude ################################## if alt_thresh == 'interactive': alt_arr = np.array([x[3] for x in meta_list[0]]) n, bins, patches = plt.hist(alt_arr, 100) plt.xlabel('Altitude') plt.ylabel('Freq') plt.show() # Ask user for alt threshold alt_thresh = input('Enter altitude threshold:') alt_thresh = float(alt_thresh) above_alt = [x[3] > alt_thresh for x in meta_list[0]] elif isinstance(alt_thresh, float): above_alt = [x[3] > alt_thresh for x in meta_list[0]] else: raise ValueError( '--alt_thresh argument must be a float or interactive') # Combine both boolean lists (altitude and in_polygon) is_valid = [x and y for x, y in zip(above_alt, in_polygon)] ######################### ### Optionally retrieve irradiance values ######################### if irradiance == 'panel': # Trying first capture, then last if doesn't work try: panel_cap = imgset.captures[0] # Auto-detect panel, perform visual check, retrieve corresponding irradiance values if panel_cap.detect_panels() != 5: raise AssertionError('Panels could not be detected') panel_cap.plot_panels() # Visual check and ask for user confirmation panel_check = input("Are panels properly detected ? (y/n):") if panel_check != 'y': raise AssertionError( 'User input, unsuitable detected panels !') except Exception as e: print( "Failed to use pre flight panels; trying post flight panel capture" ) panel_cap = imgset.captures[-1] # Auto-detect panel, perform visual check, retrieve corresponding irradiance values if panel_cap.detect_panels() != 5: raise AssertionError('Panels could not be detected') panel_cap.plot_panels() # Visual check and ask for user confirmation panel_check = input("Are panels properly detected ? (y/n):") if panel_check != 'y': raise AssertionError( 'User input, unsuitable detected panels !') # Retrieve irradiance values from panels reflectance img_type = 'reflectance' irradiance_list = panel_cap.panel_irradiance() elif irradiance == 'dls': img_type = 'reflectance' irradiance_list = None elif irradiance == 'sixs': # Pick the middle cature, and use it to model clear sky irradiance using 6s middle_c = imgset.captures[round(len(imgset.captures) / 2)] img_type = 'reflectance' irradiance_list = modeled_irradiance_from_capture(middle_c) elif irradiance is None: img_type = None irradiance_list = None else: raise ValueError( 'Incorrect value for --reflectance, must be panel, dls or left empty' ) ######################### ### Alignment parameters ######################### # Select an arbitrary image, find warping and croping parameters, apply to image, # assemble a rgb composite to perform visual check alignment_confirmed = False while not alignment_confirmed: warp_cap_ind = random.randint(1, len(imgset.captures) - 1) warp_cap = imgset.captures[warp_cap_ind] warp_matrices, alignment_pairs = imageutils.align_capture( warp_cap, max_iterations=100, multithreaded=True) print("Finished Aligning") # Retrieve cropping dimensions cropped_dimensions, edges = imageutils.find_crop_bounds( warp_cap, warp_matrices) warp_mode = alignment_pairs[0]['warp_mode'] match_index = alignment_pairs[0]['ref_index'] # Apply warping and cropping to the Capture used for finding the parameters to # later perform a visual check im_aligned = imageutils.aligned_capture(warp_cap, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type='radiance') rgb_list = [ imageutils.normalize(im_aligned[:, :, i]) for i in [0, 1, 2] ] plt.imshow(np.stack(rgb_list, axis=-1)) plt.show() cir_list = [ imageutils.normalize(im_aligned[:, :, i]) for i in [1, 3, 4] ] plt.imshow(np.stack(cir_list, axis=-1)) plt.show() alignment_check = input(""" Are all bands properly aligned? (y/n) y: Bands are properly aligned, begin processing n: Bands are not properly aliged or image is not representative of the whole set, try another image """) if alignment_check.lower() == 'y': alignment_confirmed = True else: print('Trying another image') ################## ### Processing ################# # Build iterator of captures cap_tuple_iterator = zip(imgset.captures, is_valid, range(start_count, len(is_valid) + start_count)) process_kwargs = { 'warp_matrices': warp_matrices, 'warp_mode': warp_mode, 'cropped_dimensions': cropped_dimensions, 'match_index': match_index, 'out_dir': out_dir, 'irradiance_list': irradiance_list, 'img_type': img_type, 'resolution': resolution, 'scaling': scaling } # Run process function with multiprocessing pool = mp.Pool(ncores) pool.map(functools.partial(capture_to_files, **process_kwargs), cap_tuple_iterator)
cam_mats) # ## Visualize Aligned Images # # Once the transformation has been found, it can be verified by composting the aligned images to check alignment. The image 'stack' containing all bands can also be exported to a multi-band TIFF file for viewing in extrernal software such as QGIS. Useful componsites are a naturally colored RGB as well as color infrared, or CIR. # In[ ]: im_aligned = imageutils.aligned_capture(warp_matrices, alignment_pairs, cropped_dimensions) # Create a normalized stack for viewing im_display = np.zeros((im_aligned.shape[0], im_aligned.shape[1], 5), dtype=np.float32) for i in range(0, im_aligned.shape[2]): im_display[:, :, i] = imageutils.normalize(im_aligned[:, :, i]) rgb = im_display[:, :, [2, 1, 0]] cir = im_display[:, :, [3, 2, 1]] fig, axes = plt.subplots(1, 2, figsize=(16, 16)) plt.title("Red-Green-Blue Composite") axes[0].imshow(rgb) plt.title("Color Infrared (CIR) Composite") axes[1].imshow(cir) plt.show() # ## Image Enhancement # # There are many techniques for image enhancement, but one which is commonly used to improve the visual sharpness of imagery is the unsharp mask. Here we apply an unsharp mask to the RGB image to improve the visualization, and then apply a gamma curve to make the darkest areas brighter. # In[ ]:
def proc_imgs_comp(i, warp_matrices, bndFolders, panel_irradiance, rf, warp_md): i.compute_reflectance(panel_irradiance) #i.plot_undistorted_reflectance(panel_irradiance) cropped_dimensions, edges = imageutils.find_crop_bounds(i, warp_matrices) im_aligned = imageutils.aligned_capture(i, warp_matrices, warp_md, cropped_dimensions, match_index=rf, img_type="reflectance") im_display = np.zeros((im_aligned.shape[0], im_aligned.shape[1], 5), dtype=np.float32) for iM in range(0, im_aligned.shape[2]): im_display[:, :, iM] = imageutils.normalize(im_aligned[:, :, iM]) * 32768 rgb = im_display[:, :, [2, 1, 0]] #cir = im_display[:,:,[3,2,1]] RRENir = im_display[:, :, [4, 3, 2]] # cir = im_display[:,:,[3,2,1]] # # grRE = im_display[:,:,[4,2,1]] # # imoot = [rgb, RRENir] del im_display imtags = ["RGB.tif", "RRENir.tif"] #, "GRNir.tif", "GRRE.tif"] im = i.images[1] hd, nm = os.path.split(im.path[:-5]) #cmdList = [] def _writeim(image, folder, nametag, im): #for ind, k in enumerate(bndFolders): #img8 = bytescale(imoot[ind]) #imgre = exposure.rescale_intensity(image, out_range='uint16') #with warnings.catch_warnings(): #warnings.simplefilter("ignore") img16 = np.uint16(np.round(image, decimals=0)) del image outFile = os.path.join(folder, nm + nametag) #imageio.imwrite(outfile, img8) #imOut = Image.fromarray(img16) #imOut.save(outFile) imageio.imwrite(outFile, img16) del img16 cmd = [ "exiftool", "-tagsFromFile", im.path, "-file:all", "-iptc:all", "-exif:all", "-xmp", "-Composite:all", outFile, "-overwrite_original" ] call(cmd) _writeim(rgb, bndFolders[0], imtags[0], im) del rgb _writeim(RRENir, bndFolders[1], imtags[1], im) del RRENir #,
def stackImages(FILE, imageNames, panelNames=None): import os, glob import micasense.capture as capture import cv2 import numpy as np import matplotlib.pyplot as plt import micasense.imageutils as imageutils import micasense.plotutils as plotutils # Allow this code to align both radiance and reflectance images; bu excluding # a definition for panelNames above, radiance images will be used # For panel images, efforts will be made to automatically extract the panel information # but if the panel/firmware is before Altum 1.3.5, RedEdge 5.1.7 the panel reflectance # will need to be set in the panel_reflectance_by_band variable. # Note: radiance images will not be used to properly create NDVI/NDRE images below. if panelNames is not None: panelCap = capture.Capture.from_filelist(panelNames) else: panelCap = None capture = capture.Capture.from_filelist(imageNames) if panelCap is not None: if panelCap.panel_albedo() is not None: panel_reflectance_by_band = panelCap.panel_albedo() else: panel_reflectance_by_band = [0.67, 0.69, 0.68, 0.61, 0.67] #RedEdge band_index order panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band) img_type = "reflectance" capture.plot_undistorted_reflectance(panel_irradiance) else: if capture.dls_present(): img_type = 'reflectance' #capture.plot_undistorted_reflectance(capture.dls_irradiance()) else: img_type = "radiance" #capture.plot_undistorted_radiance() ## Alignment settings match_index = 1 # Index of the band max_alignment_iterations = 10 warp_mode = cv2.MOTION_HOMOGRAPHY # MOTION_HOMOGRAPHY or MOTION_AFFINE. For Altum images only use HOMOGRAPHY pyramid_levels = 0 # for images with RigRelatives, setting this to 0 or 1 may improve alignment print( "Aligning images. Depending on settings this can take from a few seconds to many minutes" ) # Can potentially increase max_iterations for better results, but longer runtimes warp_matrices, alignment_pairs = imageutils.align_capture( capture, ref_index=match_index, max_iterations=max_alignment_iterations, warp_mode=warp_mode, pyramid_levels=pyramid_levels) if warp_matrices == -1: return -1 print("Finished Aligning, warp matrices={}".format(warp_matrices)) cropped_dimensions, edges = imageutils.find_crop_bounds( capture, warp_matrices, warp_mode=warp_mode) im_aligned = imageutils.aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type=img_type) # Create a normalized stack for viewing im_display = np.zeros( (im_aligned.shape[0], im_aligned.shape[1], im_aligned.shape[2]), dtype=np.float32) from osgeo import gdal, gdal_array rows, cols, bands = im_display.shape driver = gdal.GetDriverByName('GTiff') filename = FILE + "stacked" #blue,green,red,nir,redEdge filename = os.path.join(directory, filename) outRaster = driver.Create(filename + ".tiff", cols, rows, im_aligned.shape[2], gdal.GDT_UInt16) normalize = (img_type == 'radiance' ) # normalize radiance images to fit with in UInt16 # Output a 'stack' in the same band order as RedEdge/Alutm # Blue,Green,Red,NIR,RedEdge[,Thermal] # reflectance stacks are output with 32768=100% reflectance to provide some overhead for specular reflections # radiance stacks are output with 65535=100% radiance to provide some overhead for specular reflections # NOTE: NIR and RedEdge are not in wavelength order! multispec_min = np.min(im_aligned[:, :, 1:5]) multispec_max = np.max(im_aligned[:, :, 1:5]) for i in range(0, 5): outband = outRaster.GetRasterBand(i + 1) if normalize: outdata = imageutils.normalize(im_aligned[:, :, i], multispec_min, multispec_max) else: outdata = im_aligned[:, :, i] outdata[outdata < 0] = 0 outdata[outdata > 2] = 2 outdata = outdata * 32767 outdata[outdata < 0] = 0 outdata[outdata > 65535] = 65535 outband.WriteArray(outdata) outband.FlushCache() if im_aligned.shape[2] == 6: outband = outRaster.GetRasterBand(6) outdata = im_aligned[:, :, 5] * 100 # scale to centi-C to fit into uint16 outdata[outdata < 0] = 0 outdata[outdata > 65535] = 65535 outband.WriteArray(outdata) outband.FlushCache() outRaster = None return 1