+
+
+
+
+
+
+
+
+Active Image Alignment¶
For most use cases, each band of a multispectral capture must be aligned with the other bands in order to create meaningful data. In this tutorial, we show how to align the band to each other using open source OpenCV utilities.
+Image alignment allows the combination of images into true-color (RGB) and false color (such as CIR) composites, useful for scouting using single images as well as for display and management uses. In addition to composite images, alignment allows the calculation of pixel-accurate indices such as NDVI or NDRE at the single image level which can be very useful for applications like plant counting and coverage estimations, where mosaicing artifacts may otherwise skew analysis results.
+The image alignment method described below tends to work well on images with abundant image features, or areas of significant contrast. Cars, buildings, parking lots, and roads tend to provide the best results. This approach may not work well on images which contain few features or very repetitive features, such as full canopy row crops or fields of repetitive small crops such lettuce or strawberries. We will disscuss more about the advantages and disadvantages of these methods below.
+The functions behind this alignment process can work with most versions of RedEdge and Altum firmware. They will work best with RedEdge (3,M,MX) versions above 3.2.0 which include the "RigRelatives" tags, and all RedEdge-P/Altum/Altum-PT imagery. These tags provide a starting point for the image transformation and can help to ensure convergence of the algorithm.
+Opening Images¶
As we have done in previous examples, we use the micasense.capture class to open, radiometrically correct, and visualize all the bands of a MicaSense capture.
+First, we'll load the autoreload extension. This lets us change underlying code (such as library functions) without having to reload the entire workbook and kernel. This is useful in this workbook because the cell that runs the alignment can take a long time to run, so with the autoreload extension we can update the code after the alignment step for analysis and visualization without needing to re-compute the alignments each time.
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+import os, glob
+import micasense.capture as capture
+%matplotlib inline
+from pathlib import Path
+import matplotlib.pyplot as plt
+plt.rcParams["figure.facecolor"] = "w"
+
+panelNames = None
+
+# set your image paths here. See more here: https://docs.python.org/3/library/pathlib.html
+# if using Windows, you need to an an "r" to the path like this: Path(r"C:\Files")
+
+# imagePath = Path("./data/REDEDGE-MX-DUAL")
+
+# # these will return lists of image paths as strings
+# imageNames = list(imagePath.glob('IMG_0007_*.tif'))
+# imageNames = [x.as_posix() for x in imageNames]
+
+# panelNames = list(imagePath.glob('IMG_0001_*.tif'))
+# panelNames = [x.as_posix() for x in panelNames]
+
+# imagePath = Path("./data/REDEDGE-MX")
+
+# # these will return lists of image paths as strings
+# imageNames = list(imagePath.glob('IMG_0020_*.tif'))
+# imageNames = [x.as_posix() for x in imageNames]
+
+# panelNames = list(imagePath.glob('IMG_0001_*.tif'))
+# panelNames = [x.as_posix() for x in panelNames]
+
+imagePath = Path("./data/ALTUM-PT")
+
+# these will return lists of image paths as strings
+imageNames = list(imagePath.glob('IMG_0010_*.tif'))
+imageNames = [x.as_posix() for x in imageNames]
+
+panelNames = list(imagePath.glob('IMG_0000_*.tif'))
+panelNames = [x.as_posix() for x in panelNames]
+
+# imagePath = Path("./data/ALTUM")
+
+# # these will return lists of image paths as strings
+# imageNames = list(imagePath.glob('IMG_0021_*.tif'))
+# imageNames = [x.as_posix() for x in imageNames]
+
+# panelNames = list(imagePath.glob('IMG_0000_*.tif'))
+# panelNames = [x.as_posix() for x in panelNames]
+
+# imagePath = Path("./data/REDEDGE-P")
+
+# # these will return lists of image paths as strings
+# imageNames = list(imagePath.glob('IMG_0011_*.tif'))
+# imageNames = [x.as_posix() for x in imageNames]
+
+# panelNames = list(imagePath.glob('IMG_0000_*.tif'))
+# panelNames = [x.as_posix() for x in panelNames]
+
+
+if panelNames is not None:
+ panelCap = capture.Capture.from_filelist(panelNames)
+else:
+ panelCap = None
+
+thecapture = capture.Capture.from_filelist(imageNames)
+
+# get camera model for future use
+cam_model = thecapture.camera_model
+# if this is a multicamera system like the RedEdge-MX Dual,
+# we can combine the two serial numbers to help identify
+# this camera system later.
+if len(thecapture.camera_serials) > 1:
+ cam_serial = "_".join(thecapture.camera_serials)
+ print(cam_serial)
+else:
+ cam_serial = thecapture.camera_serial
+
+print("Camera model:",cam_model)
+print("Bit depth:", thecapture.bits_per_pixel)
+print("Camera serial number:", cam_serial)
+print("Capture ID:",thecapture.uuid)
+
+# determine if this sensor has a panchromatic band
+if cam_model == 'RedEdge-P' or cam_model == 'Altum-PT':
+ panchroCam = True
+else:
+ panchroCam = False
+ panSharpen = False
+
+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.49]*len(thecapture.eo_band_names()) #RedEdge band_index order
+ panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band)
+ img_type = "reflectance"
+ thecapture.plot_undistorted_reflectance(panel_irradiance)
+else:
+ if thecapture.dls_present():
+ img_type='reflectance'
+ thecapture.plot_undistorted_reflectance(thecapture.dls_irradiance())
+ else:
+ img_type = "radiance"
+ thecapture.plot_undistorted_radiance()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Camera model: Altum-PT +Bit depth: 12 +Camera serial number: PA01-2210071-MS +Capture ID: Z9WKG9xZ2rL9gFGQopS0 ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Check for existing warp matrices¶
If we have already successfully aligned captures from this specific camera, we can typically save some time and use the alignment warp matrices for other captures from the same camera
+ +
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+from skimage.transform import ProjectiveTransform
+import numpy as np
+
+if panchroCam:
+ warp_matrices_filename = cam_serial + "_warp_matrices_SIFT.npy"
+else:
+ warp_matrices_filename = cam_serial + "_warp_matrices_opencv.npy"
+
+if Path('./' + warp_matrices_filename).is_file():
+ print("Found existing warp matrices for camera", cam_serial)
+ load_warp_matrices = np.load(warp_matrices_filename, allow_pickle=True)
+ loaded_warp_matrices = []
+ for matrix in load_warp_matrices:
+ if panchroCam:
+ transform = ProjectiveTransform(matrix=matrix.astype('float64'))
+ loaded_warp_matrices.append(transform)
+ else:
+ loaded_warp_matrices.append(matrix.astype('float32'))
+ print("Warp matrices successfully loaded.")
+
+ if panchroCam:
+ warp_matrices_SIFT = loaded_warp_matrices
+ else:
+ warp_matrices = loaded_warp_matrices
+else:
+ print("No existing warp matrices found. Create them later in the notebook.")
+ warp_matrices_SIFT = False
+ warp_matrices = False
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Found existing warp matrices for camera PA01-2210071-MS +Warp matrices successfully loaded. ++
+
+
+
+
+
+
+
+
+Unwarp and Align (OpenCV method for RedEdge3/M/MX/Dual and original Altum)¶
Alignment is a three-step process:
+Images are unwarped using the built-in lens calibration +A transformation is found to align each band to a common band +The aligned images are combined and cropped, removing pixels which don't overlap in all bands. +We provide utilities to find the alignment transformations within a single capture. Our experience shows that once a good alignment transformation is found, it tends to be stable over a flight and, in most cases, over many flights. The transformation may change if the camera undergoes a shock event (such as a hard landing or drop) or if the temperature changes substantially between flights. In these events, a new transformation may need to be found.
+Further, since this approach finds a 2-dimensional (affine) transformation between images, it won't work when the parallax between bands results in a 3-dimensional depth field. This can happen if very close to the target or when targets are visible at significantly different ranges, such as a nearby tree or building against a background much farther way. In these cases, it will be necessary to use photogrammetry techniques to find a 3-dimensional mapping between images.
+For best alignment results it's good to select a capture which has features which visible in all bands. Man-made objects such as cars, roads, and buildings tend to work very well, while captures of only repeating crop rows tend to work poorly. Remember, once a good transformation has been found for flight, it can be generally be applied across all of the images.
+It's also good to use an image for alignment which is taken near the same level above ground as the rest of the flights. Above approximately 35m AGL, the alignment will be consistent. However, if images taken closer to the ground are used, such as panel images, the same alignment transformation will not work for the flight data.
+ +
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+import cv2
+import time
+import numpy as np
+import matplotlib.pyplot as plt
+import micasense.imageutils as imageutils
+import micasense.plotutils as plotutils
+
+# We use a different alignment method for RedEdge-P and Altum-PT,
+# so if the imagery is from this kind of camera, skip this step
+if not panchroCam:
+ st = time.time()
+ # set to True if you'd like to ignore existing warp matrices and create new ones
+ regenerate = True
+ pyramid_levels = 0 # for images with RigRelatives, setting this to 0 or 1 may improve alignment
+ max_alignment_iterations = 10
+
+ # match_index:
+ # for non-panchromatic cameras we want to use band 1, which is green
+ # the green band has zero rig relative offsets
+ # NOTE: These band numbers are zero-indexed
+ # special parameters for RedEdge-MX dual camera system
+ if len(thecapture.eo_band_names()) == 10:
+ print("is 10 band")
+ pyramid_levels = 3
+ match_index = 4
+ max_alignment_iterations = 20
+ else:
+ match_index = 1
+
+ warp_mode = cv2.MOTION_HOMOGRAPHY # MOTION_HOMOGRAPHY or MOTION_AFFINE. For Altum images only use HOMOGRAPHY
+
+ 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
+ if warp_matrices and not regenerate:
+ print("Using existing warp matrices...")
+ try:
+ irradiance = panel_irradiance+[0]
+ except NameError:
+ irradiance = None
+ else:
+ warp_matrices, alignment_pairs = imageutils.align_capture(thecapture,
+ ref_index = match_index,
+ max_iterations = max_alignment_iterations,
+ warp_mode = warp_mode,
+ pyramid_levels = pyramid_levels)
+
+ print("Finished Aligning")
+ et = time.time()
+ elapsed_time = et - st
+ print('Alignment time:', int(elapsed_time), 'seconds')
+
+
+
+
+
+
+
+
+
+Crop Aligned Images and create aligned capture stack¶
After finding image alignments, we may need to remove pixels around the edges which aren't present in every image in the capture. To do this we use the affine transforms found above and the image distortions from the image metadata. OpenCV provides a couple of handy helpers for this task in the cv2.undistortPoints() and cv2.transform() methods. These methods take a set of pixel coordinates and apply our undistortion matrix and our affine transform, respectively. So, just as we did when registering the images, we first apply the undistortion process to the coordinates of the image borders, then we apply the affine transformation to that result. The resulting pixel coordinates tell us where the image borders end up after this pair of transformations, and we can then crop the resultant image to these coordinates.
+ +
+
+
+
+
+
+
+
+
+In [5]:
+
+
+
+
+
+
+if not panchroCam:
+ cropped_dimensions, edges = imageutils.find_crop_bounds(thecapture, warp_matrices, warp_mode=warp_mode, reference_band=match_index)
+ print("Cropped dimensions:",cropped_dimensions)
+ im_aligned = thecapture.create_aligned_capture(warp_matrices=warp_matrices, motion_type=warp_mode, img_type=img_type, match_index=match_index)
+
+
+
+
+
+
+
+
+
+Alignment and pan-sharpening for RedEdge-P and Altum-PT¶
For older cameras we use OpenCV for capture alignment. For RedEdge-P and Altum-PT, we use SIFT (scale-invariant feature transform). We will use SIFT to create the warp matrices, then use these warp matrices to align the capture. See more here: +https://scikit-image.org/docs/stable/auto_examples/features_detection/plot_sift.html +https://en.wikipedia.org/wiki/Scale-invariant_feature_transform
+For sensors with a panchromatic band (Altum-PT or RedEdge-P), we may wish to create a pan-sharpened stack. This example uses a linear interpolation method for pan-sharpening.
+The radiometric_pan_sharpen function takes in the SIFT warp matrices and outputs an upsampled image stack (all bands are changed to the resolution of the panchromatic sensor) and a pan-sharpened stack.
Note: it is important to choose an initial alignment image that has a lot of straight, manmade features, such as roads or buildings. Trying to align a capture that is strictly vegetation will take a long time and may not be very good. This process can take a while, depending on how feature-rich the capture is. We have seen some Altum-PT captures align after 2 minutes, and some can take upwards of 30 minutes. Be patient! Once an alignment has been found, it can be used on other captures from the same camera, and the alignment process will be much faster.
+ +
+
+
+
+
+
+
+
+
+In [6]:
+
+
+
+
+
+
+# from micasense.imageutils import brovey_pan_sharpen,radiometric_pan_sharpen
+from skimage.transform import ProjectiveTransform
+
+import time
+
+if panchroCam:
+ # set to True if you'd like to ignore existing warp matrices and create new ones
+ regenerate = False
+ st = time.time()
+ if not warp_matrices_SIFT or regenerate:
+ print("Generating new warp matrices...")
+ warp_matrices_SIFT = thecapture.SIFT_align_capture(min_matches = 10)
+
+ sharpened_stack, upsampled = thecapture.radiometric_pan_sharpened_aligned_capture(warp_matrices=warp_matrices_SIFT)
+
+# we can also use the Rig Relatives from the image metadata to do a quick, rudimentary alignment
+# warp_matrices0=thecapture.get_warp_matrices(ref_index=5)
+# sharpened_stack,upsampled = radiometric_pan_sharpen(thecapture,warp_matrices=warp_matrices0)
+
+ print("Pansharpened shape:", sharpened_stack.shape)
+ print("Upsampled shape:", upsampled.shape)
+ # re-assign to im_aligned to match rest of code
+ im_aligned = upsampled
+ et = time.time()
+ elapsed_time = et - st
+ print('Alignment and pan-sharpening time:', int(elapsed_time), 'seconds')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Pansharpened shape: (2990, 3980, 7) +Upsampled shape: (2990, 3980, 7) +Alignment and pan-sharpening time: 18 seconds ++
+
+
+
+
+
+
+
+
+Save warp matrices¶
Once an alignment for your camera has been found, it can be saved to a file for later use with this notebook. It can also be used on the Batch Alignment notebook for aligning all of the captures from an entire flight.
+ +
+
+
+
+
+
+
+
+
+In [7]:
+
+
+
+
+
+
+import numpy
+import skimage
+from skimage.transform import warp,matrix_transform,resize,FundamentalMatrixTransform,estimate_transform,ProjectiveTransform
+
+if panchroCam:
+ working_wm = warp_matrices_SIFT
+else:
+ working_wm = warp_matrices
+if not Path('./' + warp_matrices_filename).is_file() or regenerate:
+ temp_matrices = []
+ for x in working_wm:
+ if isinstance(x, numpy.ndarray):
+ temp_matrices.append(x)
+ if isinstance(x, skimage.transform._geometric.ProjectiveTransform):
+ temp_matrices.append(x.params)
+ np.save(warp_matrices_filename, np.array(temp_matrices, dtype=object), allow_pickle=True)
+ print("Saved to", Path('./' + warp_matrices_filename).resolve())
+else:
+ print("Matrices already exist at",Path('./' + warp_matrices_filename).resolve())
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Matrices already exist at /Users/stephen/programs/gitlab/imageProcessingTutorial/PA01-2210071-MS_warp_matrices_SIFT.npy ++
+
+
+
+
+
+
+
+
+Multispectral band histogram¶
We can compare the radiance between multispectral bands, and between upsampled/pansharpened in the case of RedEdge-P and Altum-PT
+ +
+
+
+
+
+
+
+
+
+In [8]:
+
+
+
+
+
+
+theColors = {'Blue': 'blue', 'Green': 'green', 'Red': 'red', \
+ 'Red edge': 'maroon', 'NIR': 'purple', 'Panchro': 'yellow', \
+ 'Red edge-740': 'salmon', 'Red Edge': 'maroon', 'Blue-444': 'aqua', \
+ 'Green-531': 'lime', 'Red-650': 'lightcoral', 'Red edge-705':'brown'}
+
+eo_count = len(thecapture.eo_indices())
+multispec_min = np.min(np.percentile(im_aligned[:,:,1:eo_count].flatten(),0.01))
+multispec_max = np.max(np.percentile(im_aligned[:,:,1:eo_count].flatten(), 99.99))
+
+theRange = (multispec_min,multispec_max)
+
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+for x,y in zip(thecapture.eo_indices(),thecapture.eo_band_names()):
+ axis.hist(im_aligned[:,:,x].ravel(), bins=512, range=theRange, \
+ histtype="step", label=y, color=theColors[y], linewidth=1.5)
+plt.title("Multispectral histogram (radiance)")
+axis.legend()
+plt.show()
+
+if panchroCam:
+ eo_count = len(thecapture.eo_indices())
+ multispec_min = np.min(np.percentile(sharpened_stack[:,:,1:eo_count].flatten(),0.01))
+ multispec_max = np.max(np.percentile(sharpened_stack[:,:,1:eo_count].flatten(), 99.99))
+
+ theRange = (multispec_min,multispec_max)
+
+ fig, axis = plt.subplots(1, 1, figsize=(10,4))
+ for x,y in zip(thecapture.eo_indices(),thecapture.eo_band_names()):
+ axis.hist(sharpened_stack[:,:,x].ravel(), bins=512, range=theRange, \
+ histtype="step", label=y, color=theColors[y], linewidth=1.5)
+ plt.title("Pan-sharpened multispectral histogram (radiance)")
+ axis.legend()
+ plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Visualize Aligned Images¶
Once the transformation has been found, it can be verified by compositing 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 external software such as QGIS. Useful composites are a naturally colored RGB as well as color infrared, or CIR.
+ +
+
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+# figsize=(30,23) # use this size for full-image-resolution display
+figsize=(16,13) # use this size for export-sized display
+
+rgb_band_indices = [thecapture.band_names_lower().index('red'),
+ thecapture.band_names_lower().index('green'),
+ thecapture.band_names_lower().index('blue')]
+cir_band_indices = [thecapture.band_names_lower().index('nir'),
+ thecapture.band_names_lower().index('red'),
+ thecapture.band_names_lower().index('green')]
+
+# Create normalized stacks for viewing
+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
+
+if panchroCam:
+ im_display_sharp = np.zeros((sharpened_stack.shape[0],sharpened_stack.shape[1],sharpened_stack.shape[2]), dtype=np.float32 )
+ im_min_sharp = np.percentile(sharpened_stack[:,:,rgb_band_indices].flatten(), 0.5) # modify these percentiles to adjust contrast
+ im_max_sharp = np.percentile(sharpened_stack[:,:,rgb_band_indices].flatten(), 99.5) # for many images, 0.5 and 99.5 are good values
+
+
+# for rgb true color, we use the same min and max scaling across the 3 bands to
+# maintain the "white balance" of the calibrated image
+for i in rgb_band_indices:
+ im_display[:,:,i] = imageutils.normalize(im_aligned[:,:,i], im_min, im_max)
+ if panchroCam:
+ im_display_sharp[:,:,i] = imageutils.normalize(sharpened_stack[:,:,i], im_min_sharp, im_max_sharp)
+
+rgb = im_display[:,:,rgb_band_indices]
+
+if panchroCam:
+ rgb_sharp = im_display_sharp[:,:,rgb_band_indices]
+
+nir_band = thecapture.band_names_lower().index('nir')
+red_band = thecapture.band_names_lower().index('red')
+
+ndvi = (im_aligned[:,:,nir_band] - im_aligned[:,:,red_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,red_band])
+
+# for cir false color imagery, we normalize the NIR,R,G bands within themselves, which provides
+# the classical CIR rendering where plants are red and soil takes on a blue tint
+for i in cir_band_indices:
+ im_display[:,:,i] = imageutils.normalize(im_aligned[:,:,i])
+
+cir = im_display[:,:,cir_band_indices]
+if panchroCam:
+ fig, (ax1,ax2) = plt.subplots(1, 2, figsize=figsize)
+else:
+ fig, ax1 = plt.subplots(1, 1, figsize=figsize)
+ax1.set_title("Red-Green-Blue Composite")
+ax1.imshow(rgb)
+if panchroCam:
+ ax2.set_title("Red-Green-Blue Composite (pan-sharpened)")
+ ax2.imshow(rgb_sharp)
+
+fig, (ax3,ax4) = plt.subplots(1, 2, figsize=figsize)
+ax3.set_title("NDVI")
+ax3.imshow(ndvi)
+ax4.set_title("Color Infrared (CIR) Composite")
+ax4.imshow(cir)
+
+# set custom lims if you want to zoom in to image to see more detail
+# this is useful for comparing upsampled and pan-sharpened stacks
+# custom_xlim=(1500,2000)
+# custom_ylim=(2000,1500)
+# plt.setp([ax1,ax2,ax3,ax4], xlim=custom_xlim, ylim=custom_ylim)
+
+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 [10]:
+
+
+
+
+
+
+if panchroCam:
+ rgb = rgb_sharp
+# 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.4
+gamma_corr_rgb = unsharp_rgb**(1.0/gamma)
+fig = plt.figure(figsize=figsize)
+plt.imshow(gamma_corr_rgb, aspect='equal')
+plt.axis('off')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Stack Export¶
We can easily export the stacks into an image using the GDAL library (http://www.glal.org). Once exported, these image stacks can be opened in software such as QGIS and raster operations such as NDVI or NDRE computation can be done in that software. The stacks include geographic information.
+If you prefer, you may set sort_by_wavelength to True in the save_capture_as_stack function.
Unless otherwise specified, this will save in your working folder, that is your imageprocessing directory.
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+#set output name to unique capture ID, e.g. FWoNSvgDNBX63Xv378qs
+outputName = thecapture.uuid
+
+try:
+ irradiance = panel_irradiance+[0]
+except NameError:
+ irradiance = None
+
+st = time.time()
+if panchroCam:
+ # in this example, we can export both a pan-sharpened stack and an upsampled stack
+ # so you can compare them in GIS. In practice, you would typically only output the pansharpened stack
+ thecapture.save_capture_as_stack(outputName+"-pansharpened.tif", sort_by_wavelength=False,pansharpen=True,img_type=img_type)
+ thecapture.save_capture_as_stack(outputName+"-upsampled.tif", sort_by_wavelength=False,pansharpen=False,img_type=img_type)
+else:
+ thecapture.save_capture_as_stack(outputName+".tif", sort_by_wavelength=True,img_type=img_type)
+
+et = time.time()
+elapsed_time = et - st
+print("Time to save stacks:", int(elapsed_time), "seconds.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Time to save stacks: 34 seconds. ++
+
+
+
+
+
+
+
+
+NDVI Computation¶
For raw index computation on single images, the numpy package provides a simple way to do math and simple visualization on images. Below, we compute and visualize an image histogram, and then use that to pick a color map range for visualizing the NDVI of an image.
Plant Classification¶
After computing the NDVI and prior to displaying it, we use a very rudimentary method for focusing on the plants and removing the soil and shadow information from our images and histograms. Below, we remove non-plant pixels by setting to zero any pixels in the image where the NIR reflectance is less than 20%. This helps to ensure that the NDVI and NDRE histograms aren't skewed substantially by soil noise.
+ +
+
+
+
+
+
+
+
+
+In [12]:
+
+
+
+
+
+
+from micasense import plotutils
+import matplotlib.pyplot as plt
+
+nir_band = thecapture.band_names_lower().index('nir')
+red_band = thecapture.band_names_lower().index('red')
+
+thelayer = im_aligned
+if panchroCam:
+ thelayer = sharpened_stack
+np.seterr(divide='ignore', invalid='ignore') # ignore divide by zero errors in the index calculation
+
+# Compute Normalized Difference Vegetation Index (NDVI) from the NIR(3) and RED (2) bands
+ndvi = (thelayer[:,:,nir_band] - thelayer[:,:,red_band]) / (thelayer[:,:,nir_band] + thelayer[:,:,red_band])
+print("Image type:",img_type)
+
+# remove shadowed areas (mask pixels with NIR reflectance < 20%))
+# this does not seem to work on panchro stacks
+if img_type == 'reflectance':
+ ndvi = np.ma.masked_where(thelayer[:,:,nir_band] < 0.20, ndvi)
+elif img_type == 'radiance':
+ lower_pct_radiance = np.percentile(thelayer[:,:,nir_band], 10.0)
+ ndvi = np.ma.masked_where(thelayer[:,:,nir_band] < lower_pct_radiance, ndvi)
+# Compute and display a histogram
+# ndvi_hist_min = np.min(ndvi)
+# ndvi_hist_max = np.max(ndvi)
+ndvi_hist_min = np.min(np.percentile(ndvi,0.5))
+ndvi_hist_max = np.max(np.percentile(ndvi,99.5))
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(ndvi.ravel(), bins=512, range=(ndvi_hist_min, ndvi_hist_max))
+plt.title("NDVI Histogram")
+plt.show()
+
+min_display_ndvi = 0.45 # further mask soil by removing low-ndvi values
+#min_display_ndvi = np.percentile(ndvi.flatten(), 5.0) # modify with these percentilse to adjust contrast
+max_display_ndvi = np.percentile(ndvi.flatten(), 99.5) # for many images, 0.5 and 99.5 are good values
+masked_ndvi = np.ma.masked_where(ndvi < min_display_ndvi, ndvi)
+
+#reduce the figure size to account for colorbar
+figsize=np.asarray(figsize) - np.array([3,2])
+
+#plot NDVI over an RGB basemap, with a colorbar showing the NDVI scale
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndvi,
+ figsize = (14,7),
+ title = 'NDVI filtered to only plants over RGB base layer',
+ vmin = min_display_ndvi,
+ vmax = max_display_ndvi)
+fig.savefig(thecapture.uuid+'_ndvi_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Image type: reflectance ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NDRE Computation¶
In the same manner, we can compute, filter, and display another index useful for MicaSense cameras, the Normalized Difference Red Edge (NDRE) index. We also filter out shadows and soil to ensure our display focuses only on the plant health.
+ +
+
+
+
+
+
+
+
+
+In [13]:
+
+
+
+
+
+
+# Compute Normalized Difference Red Edge Index from the NIR(3) and RedEdge(4) bands
+rededge_band = thecapture.band_names_lower().index('red edge')
+ndre = (thelayer[:,:,nir_band] - thelayer[:,:,rededge_band]) / (thelayer[:,:,nir_band] + thelayer[:,:,rededge_band])
+
+# Mask areas with shadows and low NDVI to remove soil
+masked_ndre = np.ma.masked_where(ndvi < min_display_ndvi, ndre)
+
+# Compute a histogram
+ndre_hist_min = np.min(np.percentile(masked_ndre,0.5))
+ndre_hist_max = np.max(np.percentile(masked_ndre,99.5))
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(masked_ndre.ravel(), bins=512, range=(ndre_hist_min, ndre_hist_max))
+plt.title("NDRE Histogram (filtered to only plants)")
+plt.show()
+
+min_display_ndre = np.percentile(masked_ndre, 5)
+max_display_ndre = np.percentile(masked_ndre, 99.5)
+
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndre,
+ figsize=(14,7),
+ title='NDRE filtered to only plants over RGB base layer',
+ vmin=min_display_ndre,vmax=max_display_ndre)
+fig.savefig(thecapture.uuid+'_ndre_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Thermal Imagery¶
If our image is from an Altum or Altum-PT and includes a thermal band, we can display the re-sampled and aligned thermal data over the RGB data to maintain the context of the thermal information.
+ +
+
+
+
+
+
+
+
+
+In [14]:
+
+
+
+
+
+
+if len(thecapture.lw_indices()) > 0:
+ lwir_band = thecapture.band_names_lower().index('lwir')
+
+ # by default we don't mask the thermal, since it's native resolution is much lower than the MS
+ if panchroCam:
+ masked_thermal = sharpened_stack[:,:,lwir_band]
+ else:
+ masked_thermal = im_aligned[:,:,lwir_band]
+ # Alternatively we can mask the thermal only to plants here, which is useful for large contiguous areas
+ # masked_thermal = np.ma.masked_where(ndvi < 0.45, im_aligned[:,:,5])
+
+
+ # Compute a histogram
+ fig, axis = plt.subplots(1, 1, figsize=(10,4))
+ axis.hist(masked_thermal.ravel(), bins=512, range=(np.min(np.percentile(masked_thermal,1)), np.max(np.percentile(masked_thermal,99))))
+ plt.title("Thermal Histogram")
+ plt.show()
+
+ min_display_therm = np.percentile(masked_thermal, 1)
+ max_display_therm = np.percentile(masked_thermal, 99)
+
+ fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_thermal,
+ figsize=(14,7),
+ 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")
+ fig.savefig(thecapture.uuid+'_thermal_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Red vs NIR Reflectance¶
Finally, we show a classic agricultural remote sensing output in the tassled cap plot. This plot can be useful for visualizing row crops and plots the Red Reflectance channel on the X-axis against the NIR reflectance channel on the Y-axis. This plot also clearly shows the line of the soil in that space. The tassled cap view isn't very useful for this arid data set; however, we can see the "badge of trees" of high NIR reflectance and relatively low red reflectance. This provides an example of one of the uses of aligned images for single capture analysis.
+ +
+
+
+
+
+
+
+
+
+In [15]:
+
+
+
+
+
+
+x_band = red_band
+y_band = nir_band
+x_max = np.max(np.percentile(im_aligned[:,:,x_band],99.99))
+y_max = np.max(np.percentile(im_aligned[:,:,y_band],99.99))
+
+fig = plt.figure(figsize=(12,12))
+plt.hexbin(im_aligned[:,:,x_band],im_aligned[:,:,y_band],gridsize=640,bins='log',extent=(0,x_max,0,y_max))
+ax = fig.gca()
+ax.set_xlim([0,x_max])
+ax.set_ylim([0,y_max])
+plt.xlabel("{} Reflectance".format(thecapture.band_names()[x_band]))
+plt.ylabel("{} Reflectance".format(thecapture.band_names()[y_band]))
+plt.show()
+
+if panchroCam:
+ x_band = red_band
+ y_band = nir_band
+ x_max = np.max(np.percentile(sharpened_stack[:,:,x_band],99.99))
+ y_max = np.max(np.percentile(sharpened_stack[:,:,y_band],99.99))
+
+ fig = plt.figure(figsize=(12,12))
+ plt.hexbin(sharpened_stack[:,:,x_band],sharpened_stack[:,:,y_band],gridsize=640,bins='log',extent=(0,x_max,0,y_max))
+ ax = fig.gca()
+ ax.set_xlim([0,x_max])
+ ax.set_ylim([0,y_max])
+ plt.xlabel("{} Reflectance (pan-sharpened)".format(thecapture.band_names()[x_band]))
+ plt.ylabel("{} Reflectance (pan-sharpened)".format(thecapture.band_names()[y_band]))
+ plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Print warp_matrices for usage elsewhere, such as Batch Processing¶
Lastly, we output the warp_matrices that we got for this image stack for usage elsewhere. Currently, these can be used in the Batch Processing.ipynb notebook to save reflectance-compensated stacks of images to a directory.
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Alignment-10Band.html b/docs/Alignment-10Band.html
new file mode 100644
index 00000000..727a7a45
--- /dev/null
+++ b/docs/Alignment-10Band.html
@@ -0,0 +1,15702 @@
+
+
+
+
+
+
+
+
+
+
+
+
+In [16]:
+
+
+
+
+
+
+if panchroCam:
+ print(warp_matrices_SIFT)
+else:
+ print(warp_matrices)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[<ProjectiveTransform(matrix= + [[ 4.71051427e-01, 1.81635696e-03, 6.30150447e+01], + [-2.91181288e-03, 4.69196185e-01, 1.02276511e+02], + [ 5.38572502e-07, -1.51241146e-06, 1.00000000e+00]]) at 0x7f9109f44410>, <ProjectiveTransform(matrix= + [[ 4.68668790e-01, 9.34580148e-04, 5.84716582e+01], + [-2.23630030e-03, 4.67555112e-01, 9.71512698e+01], + [ 2.90282499e-07, -1.34188378e-06, 1.00000000e+00]]) at 0x7f9109f44110>, <ProjectiveTransform(matrix= + [[ 4.70308622e-01, 1.86821829e-03, 5.15342645e+01], + [-2.12534374e-03, 4.70189903e-01, 9.11463269e+01], + [-8.44058028e-08, -1.49050229e-07, 1.00000000e+00]]) at 0x7f9109f446d0>, <ProjectiveTransform(matrix= + [[ 4.67756541e-01, 2.58999879e-03, 6.22011674e+01], + [-3.30003520e-03, 4.66852334e-01, 9.37899796e+01], + [ 1.67165473e-07, -8.40910501e-07, 1.00000000e+00]]) at 0x7f9109f441d0>, <ProjectiveTransform(matrix= + [[ 4.68418989e-01, 1.79902364e-03, 5.07127933e+01], + [-3.26474577e-03, 4.68172796e-01, 9.85409805e+01], + [-6.14928956e-07, -9.35021962e-07, 1.00000000e+00]]) at 0x7f9109f44490>, <ProjectiveTransform(matrix= + [[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.]]) at 0x7f908f2e94d0>, <ProjectiveTransform(matrix= + [[ 6.63024562e-02, 3.46707043e-04, -9.35690463e-01], + [-6.41765998e-04, 6.52823865e-02, 2.98242993e+01], + [-2.09231083e-06, -3.01713640e-07, 1.00000000e+00]]) at 0x7f908f2fa810>] ++
+
+
+
+
+
+
+
+
+Active Image Alignment - 10-band¶
Note: This notebook specifically demonstrates alignment and stack creation for 10-band data. For alignment of 5-band (RedEdge) and 6-band (Altum) data, pr more details about alignment in general, see the "Active Image Alignment" notebook.
+Opening Images¶
As we have done in previous examples, we use the micasense.capture class to open, radiometrically correct, and visualize the 10 bands of a RedEdge-MX Dual (Red+Blue) capture.
+First, we'll load the autoreload extension. This lets us change underlying code (such as library functions) without having to reload the entire workbook and kernel. This is useful in this workbook because the cell that runs the alignment can take a long time to run, so with autoreload extension we can update the code after the alignment step for analysis and visualization without needing to re-compute the alignments each time.
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+import os, glob
+import micasense.capture as capture
+%matplotlib inline
+
+panelNames = None
+paneCap = None
+
+imagePath = os.path.join('.','data','REDEDGE-MX-DUAL')
+imageNames = glob.glob(os.path.join(imagePath,'IMG_0007_*.tif'))
+panelNames = glob.glob(os.path.join(imagePath,'IMG_0001_*.tif'))
+
+# 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:
+ raise IOError("Comment this lne and set panel_reflectance_by_band here")
+ panel_reflectance_by_band = [0.65]*len(imageNames)
+ 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()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Unwarp and Align¶
Alignment is a three step process:
+-
+
- Images are unwarped using the built-in lens calibration +
- A transformation is found to align each band to a common band +
- The aligned images are combined and cropped, removing pixels which don't overlap in all bands. +
We provide utilities to find the alignement transformations within a single capture. Our experience shows that once a good alignmnet transformation is found, it tends to be stable over a flight and, in most cases, over many flights. The transformation may change if the camera undergoes a shock event (such as a hard landing or drop) or if the temperature changes substantially between flights. In these events a new transformation may need to be found.
+Further, since this approach finds a 2-dimensional (affine) transformation between images, it won't work when the parallax between bands results in a 3-dimensional depth field. This can happen if very close to the target or when targets are visible at significantly different ranges, such as a nearby tree or building against a background much farther way. In these cases it will be necessary to use photogrammetry techniques to find a 3-dimensional mapping between images.
+For best alignment results it's good to select a capture which has features which visible in all bands. Man-made objects such as cars, roads, and buildings tend to work very well, while captures of only repeating crop rows tend to work poorly. Remember, once a good transformation has been found for flight, it can be generally be applied across all of the images.
+It's also good to use an image for alignment which is taken near the same level above ground as the rest of the flights. Above approximately 35m AGL, the alignement will be consistent. However, if images taken closer to the ground are used, such as panel images, the same alignment transformation will not work for the flight data.
+ +
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import micasense.imageutils as imageutils
+import micasense.plotutils as plotutils
+
+## Alignment settings
+match_index = 4 # Index of the band, here we use green
+max_alignment_iterations = 20
+warp_mode = cv2.MOTION_HOMOGRAPHY # MOTION_HOMOGRAPHY or MOTION_AFFINE. For Altum images only use HOMOGRAPHY
+pyramid_levels = 3 # for 10-band imagery we use a 3-level pyramid. In some cases
+
+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)
+
+print("Finished Aligning, warp matrices={}".format(warp_matrices))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Aligning images. Depending on settings this can take from a few seconds to many minutes +Finished aligning band 4 +Finished aligning band 0 +Finished aligning band 3 +Finished aligning band 1 +Finished aligning band 2 +Finished aligning band 6 +Finished aligning band 5 +Finished aligning band 8 +Finished aligning band 7 +Finished aligning band 9 +Finished Aligning, warp matrices=[array([[ 9.7928989e-01, 1.3615261e-04, 1.9574374e-02], + [-3.7023663e-03, 9.9245304e-01, 2.8355631e+01], + [-1.0651237e-05, 2.6095395e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9525303e-01, -7.0169556e-04, -6.3409243e+00], + [-7.1914408e-05, 9.9811482e-01, -6.2239196e-02], + [-3.6460631e-06, 1.8568957e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9596852e-01, -2.5820474e-03, -1.2950540e+01], + [ 2.8751660e-03, 9.9919146e-01, 2.6645420e+01], + [-1.8280600e-06, 2.3902323e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9592507e-01, 4.5777867e-03, 1.4982515e+01], + [-3.4031910e-03, 9.9773425e-01, 2.2611160e+01], + [-9.0995320e-07, 2.3299665e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0000000e+00, 2.8202797e-20, 8.9091027e-15], + [-5.6938062e-19, 1.0000000e+00, 6.4872178e-15], + [-1.2599002e-21, 1.3424955e-23, 1.0000000e+00]], dtype=float32), array([[ 9.9348122e-01, -1.8129036e-02, 1.1003100e+00], + [ 1.2132729e-02, 9.9091125e-01, 2.8742294e+01], + [-2.9285566e-06, -6.2816152e-06, 1.0000000e+00]], dtype=float32), array([[ 9.8954433e-01, -1.8810771e-02, 1.1892141e+01], + [ 1.3862181e-02, 9.8975760e-01, 2.0044521e+01], + [-4.0683108e-06, -4.2664565e-06, 1.0000000e+00]], dtype=float32), array([[ 9.8794365e-01, -1.2153405e-02, 1.8298512e+01], + [ 8.4343022e-03, 9.8829275e-01, 2.8633160e+01], + [-2.5430195e-06, -3.1491891e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9505156e-01, -1.7393423e-02, 3.6898847e+00], + [ 1.3367594e-02, 9.9287426e-01, 1.8703876e+01], + [-1.3000300e-06, -4.7085673e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9182397e-01, -1.2042225e-02, 1.2686370e+01], + [ 7.6934961e-03, 9.8897797e-01, 2.7970253e+01], + [-9.2655773e-07, -6.0620891e-06, 1.0000000e+00]], dtype=float32)] ++
+
+
+
+
+
+
+
+
+Crop Aligned Images¶
After finding image alignments we may need to remove pixels around the edges which aren't present in every image in the capture. To do this we use the affine transforms found above and the image distortions from the image metadata. OpenCV provides a couple of handy helpers for this task in the cv2.undistortPoints() and cv2.transform() methods. These methods takes a set of pixel coordinates and apply our undistortion matrix and our affine transform, respectively. So, just as we did when registering the images, we first apply the undistortion process the coordinates of the image borders, then we apply the affine transformation to that result. The resulting pixel coordinates tell us where the image borders end up after this pair of transformations, and we can then crop the resultant image to these coordinates.
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+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)
+display(im_aligned)
+print("fff")
+im_aligned = capture.create_aligned_capture(warp_matrices=warp_matrices, motion_type=warp_mode, img_type=img_type, match_index=match_index)
+display(im_aligned)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+array([[[0.04449825, 0.05834329, 0.05699025, ..., 0.0528319 , + 0.07618934, 0.13635507], + [0.04551493, 0.05871509, 0.0533512 , ..., 0.05375743, + 0.07973219, 0.13832156], + [0.04553824, 0.06390802, 0.05610467, ..., 0.05398859, + 0.08443005, 0.14852835], + ..., + [0.05893659, 0.07230809, 0.05917593, ..., 0.06073643, + 0.09398529, 0.21687469], + [0.05003324, 0.0664675 , 0.05700499, ..., 0.05660931, + 0.08722617, 0.20154284], + [0.04540764, 0.06866231, 0.05971338, ..., 0.05768275, + 0.08611467, 0.19954923]], + + [[0.043996 , 0.05818984, 0.05566213, ..., 0.0515653 , + 0.07534796, 0.12414938], + [0.04554788, 0.05788112, 0.05298578, ..., 0.05173871, + 0.076417 , 0.12747806], + [0.04729695, 0.06531452, 0.05632412, ..., 0.05696491, + 0.07990886, 0.15101017], + ..., + [0.06180993, 0.07528408, 0.06261701, ..., 0.06480689, + 0.1002305 , 0.21519387], + [0.05216246, 0.06675215, 0.05966157, ..., 0.05824959, + 0.09197214, 0.20033701], + [0.04686544, 0.0696869 , 0.06084135, ..., 0.05859195, + 0.08765141, 0.19360156]], + + [[0.04719513, 0.05703212, 0.05228514, ..., 0.05184768, + 0.08116278, 0.130595 ], + [0.04736948, 0.06186526, 0.05192235, ..., 0.05348465, + 0.07854285, 0.13192512], + [0.04892166, 0.06844062, 0.05518164, ..., 0.05929117, + 0.08475667, 0.15392922], + ..., + [0.06107106, 0.07277559, 0.06353831, ..., 0.06612159, + 0.09967496, 0.2089769 ], + [0.05610751, 0.06975867, 0.06273928, ..., 0.0632534 , + 0.09190915, 0.1867479 ], + [0.04991827, 0.07058094, 0.06168615, ..., 0.06201676, + 0.08668306, 0.17329696]], + + ..., + + [[0.03752367, 0.09495717, 0.06308448, ..., 0.06055268, + 0.11859115, 0.36167163], + [0.03716302, 0.09172834, 0.06215791, ..., 0.05819597, + 0.11055551, 0.36911854], + [0.03741182, 0.08998678, 0.05918581, ..., 0.05523164, + 0.10871691, 0.37251878], + ..., + [0.17053236, 0.20084937, 0.2656319 , ..., 0.23127253, + 0.21557146, 0.22828759], + [0.16936235, 0.19811206, 0.2181453 , ..., 0.19929384, + 0.19923317, 0.2175055 ], + [0.17199045, 0.19134107, 0.20697866, ..., 0.20128694, + 0.20539421, 0.21508098]], + + [[0.03794758, 0.09345208, 0.06537206, ..., 0.0648974 , + 0.11819842, 0.36217105], + [0.03913194, 0.09361731, 0.06283107, ..., 0.06258071, + 0.11491562, 0.37606257], + [0.0391482 , 0.09110615, 0.06024874, ..., 0.05788773, + 0.10959219, 0.36674654], + ..., + [0.16886954, 0.20589119, 0.282101 , ..., 0.24447776, + 0.22555993, 0.24048506], + [0.16768672, 0.20429438, 0.2303536 , ..., 0.2075679 , + 0.21025576, 0.22479147], + [0.16860068, 0.1963228 , 0.21333084, ..., 0.20610072, + 0.21020785, 0.2212299 ]], + + [[0.03912217, 0.09133695, 0.06471822, ..., 0.06551831, + 0.11582895, 0.3591986 ], + [0.03989396, 0.09222235, 0.06317808, ..., 0.06262669, + 0.11217536, 0.35820585], + [0.04026981, 0.08995611, 0.0575012 , ..., 0.05748435, + 0.1085691 , 0.35474142], + ..., + [0.17024775, 0.20644474, 0.29202968, ..., 0.2621528 , + 0.23570539, 0.24650206], + [0.16856626, 0.2006478 , 0.24013193, ..., 0.21821336, + 0.21899852, 0.22762969], + [0.16514897, 0.19955555, 0.22367412, ..., 0.21459754, + 0.21694328, 0.22302781]]], dtype=float32)+
+
+
+
+
+
+
+
+
+
+fff ++
+
+
+
+
+
+
+
+
+
+
+
+
+array([[[0.04449825, 0.05834329, 0.05699025, ..., 0.0528319 , + 0.07618934, 0.13635507], + [0.04551493, 0.05871509, 0.0533512 , ..., 0.05375743, + 0.07973219, 0.13832156], + [0.04553824, 0.06390802, 0.05610467, ..., 0.05398859, + 0.08443005, 0.14852835], + ..., + [0.05893659, 0.07230809, 0.05917593, ..., 0.06073643, + 0.09398529, 0.21687469], + [0.05003324, 0.0664675 , 0.05700499, ..., 0.05660931, + 0.08722617, 0.20154284], + [0.04540764, 0.06866231, 0.05971338, ..., 0.05768275, + 0.08611467, 0.19954923]], + + [[0.043996 , 0.05818984, 0.05566213, ..., 0.0515653 , + 0.07534796, 0.12414938], + [0.04554788, 0.05788112, 0.05298578, ..., 0.05173871, + 0.076417 , 0.12747806], + [0.04729695, 0.06531452, 0.05632412, ..., 0.05696491, + 0.07990886, 0.15101017], + ..., + [0.06180993, 0.07528408, 0.06261701, ..., 0.06480689, + 0.1002305 , 0.21519387], + [0.05216246, 0.06675215, 0.05966157, ..., 0.05824959, + 0.09197214, 0.20033701], + [0.04686544, 0.0696869 , 0.06084135, ..., 0.05859195, + 0.08765141, 0.19360156]], + + [[0.04719513, 0.05703212, 0.05228514, ..., 0.05184768, + 0.08116278, 0.130595 ], + [0.04736948, 0.06186526, 0.05192235, ..., 0.05348465, + 0.07854285, 0.13192512], + [0.04892166, 0.06844062, 0.05518164, ..., 0.05929117, + 0.08475667, 0.15392922], + ..., + [0.06107106, 0.07277559, 0.06353831, ..., 0.06612159, + 0.09967496, 0.2089769 ], + [0.05610751, 0.06975867, 0.06273928, ..., 0.0632534 , + 0.09190915, 0.1867479 ], + [0.04991827, 0.07058094, 0.06168615, ..., 0.06201676, + 0.08668306, 0.17329696]], + + ..., + + [[0.03752367, 0.09495717, 0.06308448, ..., 0.06055268, + 0.11859115, 0.36167163], + [0.03716302, 0.09172834, 0.06215791, ..., 0.05819597, + 0.11055551, 0.36911854], + [0.03741182, 0.08998678, 0.05918581, ..., 0.05523164, + 0.10871691, 0.37251878], + ..., + [0.17053236, 0.20084937, 0.2656319 , ..., 0.23127253, + 0.21557146, 0.22828759], + [0.16936235, 0.19811206, 0.2181453 , ..., 0.19929384, + 0.19923317, 0.2175055 ], + [0.17199045, 0.19134107, 0.20697866, ..., 0.20128694, + 0.20539421, 0.21508098]], + + [[0.03794758, 0.09345208, 0.06537206, ..., 0.0648974 , + 0.11819842, 0.36217105], + [0.03913194, 0.09361731, 0.06283107, ..., 0.06258071, + 0.11491562, 0.37606257], + [0.0391482 , 0.09110615, 0.06024874, ..., 0.05788773, + 0.10959219, 0.36674654], + ..., + [0.16886954, 0.20589119, 0.282101 , ..., 0.24447776, + 0.22555993, 0.24048506], + [0.16768672, 0.20429438, 0.2303536 , ..., 0.2075679 , + 0.21025576, 0.22479147], + [0.16860068, 0.1963228 , 0.21333084, ..., 0.20610072, + 0.21020785, 0.2212299 ]], + + [[0.03912217, 0.09133695, 0.06471822, ..., 0.06551831, + 0.11582895, 0.3591986 ], + [0.03989396, 0.09222235, 0.06317808, ..., 0.06262669, + 0.11217536, 0.35820585], + [0.04026981, 0.08995611, 0.0575012 , ..., 0.05748435, + 0.1085691 , 0.35474142], + ..., + [0.17024775, 0.20644474, 0.29202968, ..., 0.2621528 , + 0.23570539, 0.24650206], + [0.16856626, 0.2006478 , 0.24013193, ..., 0.21821336, + 0.21899852, 0.22762969], + [0.16514897, 0.19955555, 0.22367412, ..., 0.21459754, + 0.21694328, 0.22302781]]], dtype=float32)+
+
+
+
+
+
+
+
+
+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. Usef ul componsites are a naturally colored RGB as well as color infrared, or CIR.
+ +
+
+
+
+
+
+
+
+
+In [5]:
+
+
+
+
+
+
+# figsize=(30,23) # use this size for full-image-resolution display
+figsize=(16,13) # use this size for export-sized display
+
+rgb_band_indices = [capture.band_names().index('Red'),capture.band_names().index('Green'),capture.band_names().index('Blue-444')]
+cir_band_indices = [capture.band_names().index('NIR'),capture.band_names().index('Red'),capture.band_names().index('Green')]
+
+# 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 )
+
+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 rgb true color, we use the same min and max scaling across the 3 bands to
+# maintain the "white balance" of the calibrated image
+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 cir false color imagery, we normalize the NIR,R,G bands within themselves, which provides
+# the classical CIR rendering where plants are red and soil takes on a blue tint
+for i in cir_band_indices:
+ im_display[:,:,i] = imageutils.normalize(im_aligned[:,:,i])
+
+cir = im_display[:,:,cir_band_indices]
+fig, axes = plt.subplots(1, 2, figsize=figsize)
+axes[0].set_title("Red-Green-Blue Composite")
+axes[0].imshow(rgb)
+axes[1].set_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 [6]:
+
+
+
+
+
+
+# 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.4
+gamma_corr_rgb = unsharp_rgb**(1.0/gamma)
+fig = plt.figure(figsize=figsize)
+plt.imshow(gamma_corr_rgb, aspect='equal')
+plt.axis('off')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Image Export¶
Composite images can be exported to JPEG or PNG format using the imageio package. These images may be useful for visualization or thumbnailing, and creating RGB thumbnails of a set of images can provide a convenient way to browse the imagery in a more visually appealing way that browsing the raw imagery.
+
+
+
+
+
+
+
+
+In [7]:
+
+
+
+
+
+
+import imageio
+imtype = 'png' # or 'jpg'
+imageio.imwrite('rgb.'+imtype, (255*gamma_corr_rgb).astype('uint8'))
+imageio.imwrite('cir.'+imtype, (255*cir).astype('uint8'))
+
+
+
+
+
+
+
+
+
+Stack Export¶
We can export the image easily stacks using the gdal library (http://www.glal.org). Once exported, these image stacks can be opened in software such as QGIS and raster operations such as NDVI or NDRE computation can be done in that software. At this time the stacks don't include any geographic information.
+
+
+
+
+
+
+
+
+In [8]:
+
+
+
+
+
+
+from osgeo import gdal, gdal_array
+rows, cols, bands = im_display.shape
+driver = gdal.GetDriverByName('GTiff')
+filename = "bbggrreeen" #blue,blue,green,green,red,red,rededge,rededge,rededge,nir
+
+sort_by_wavelength = True # set to false if you want stacks in camera-band-index order
+
+outRaster = driver.Create(filename+"C.tiff", cols, rows, bands, gdal.GDT_UInt16, options = [ 'INTERLEAVE=BAND','COMPRESS=DEFLATE' ])
+try:
+ if outRaster is None:
+ raise IOError("could not load gdal GeoTiff driver")
+
+ if sort_by_wavelength:
+ eo_list = list(np.argsort(capture.center_wavelengths()))
+ else:
+ eo_list = capture.eo_indices()
+
+ for outband,inband in enumerate(eo_list):
+ outband = outRaster.GetRasterBand(outband+1)
+ outdata = im_aligned[:,:,inband]
+ outdata[outdata<0] = 0
+ outdata[outdata>2] = 2 #limit reflectance data to 200% to allow some specular reflections
+ outband.WriteArray(outdata*32768) # scale reflectance images so 100% = 32768
+ outband.FlushCache()
+
+ for outband,inband in enumerate(capture.lw_indices()):
+ outband = outRaster.GetRasterBand(len(eo_list)+outband+1)
+ outdata = (im_aligned[:,:,inband]+273.15) * 100 # scale data from float degC to back to centi-Kelvin to fit into uint16
+ outdata[outdata<0] = 0
+ outdata[outdata>65535] = 65535
+ outband.WriteArray(outdata)
+ outband.FlushCache()
+finally:
+ outRaster = None
+
+
+
+
+
+
+
+
+
+
+Notes on Alignment and Stack Usage¶
"Stacks" as described above are useful in a number of processing cases. For example, at the time of this writing, many photogrammetry suites could import and process stack files without significantly impacting the radiometric processing which has already been accomplished.
+Running photogrammetry on stack files instead of raw image files has both advantages and drawbacks. The primary advantage has been found to be an increase in processing speed and a reduction in program memory usage. As the photogrammetric workflow generally operates on luminance images and may not use color information, stacked images may require similar resources and be processed at a similar speed as single-band images. This is because one band of the stack can be used to generate the matching feature space while the others are ignored for matching purposes. This reduces the feature space 5-fold over matching using all images separately.
+One disadvantage is that stacking images outside of the photogrammetric workflow may result in poor image matching. The RedEdge is known to have stable lens characteristics over the course of normal operation, but variations in temperature or impacts to the camera through handling or rough landings may change the image alignment parameters. For this reason, we recommend finding a matching transformation for each flight (each take-off and landing). Alignment transformations from multiple images within a flight can be compared to find the best transformation to apply to the set of the flight. While not described or supported in this generic implementation, some matching algorithms can use a "seed" value as a starting point to speed up matching. For most cases, this seed could be the transformation found in a previous flight, or another source of a known good transformation.
+ +
+
+
+
+
+
+
+
+
+NDVI Computation¶
For raw index computation on single images, the numpy package provides a simple way to do math and simple visualizatoin on images. Below, we compute and visualize an image histogram and then use that to pick a colormap range for visualizing the NDVI of an image.
+Plant Classification¶
After computing the NDVI and prior to displaying it, we use a very rudimentary method for focusing on the plants and removing the soil and shadow information from our images and histograms. Below we remove non-plant pixels by setting to zero any pixels in the image where the NIR reflectance is less than 20%. This helps to ensure that the NDVI and NDRE histograms aren't skewed substantially by soil noise.
+ +
+
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+from micasense import plotutils
+import matplotlib.pyplot as plt
+
+nir_band = [name.lower() for name in capture.band_names()].index('nir')
+red_band = [name.lower() for name in capture.band_names()].index('red')
+
+np.seterr(divide='ignore', invalid='ignore') # ignore divide by zero errors in the index calculation
+
+# Compute Normalized Difference Vegetation Index (NDVI) from the NIR(3) and RED (2) bands
+ndvi = (im_aligned[:,:,nir_band] - im_aligned[:,:,red_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,red_band])
+
+# remove shadowed areas (mask pixels with NIR reflectance < 20%))
+if img_type == 'reflectance':
+ ndvi = np.ma.masked_where(im_aligned[:,:,nir_band] < 0.20, ndvi)
+elif img_type == 'radiance':
+ lower_pct_radiance = np.percentile(im_aligned[:,:,3], 10.0)
+ ndvi = np.ma.masked_where(im_aligned[:,:,nir_band] < lower_pct_radiance, ndvi)
+
+# Compute and display a histogram
+ndvi_hist_min = np.min(ndvi)
+ndvi_hist_max = np.max(ndvi)
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(ndvi.ravel(), bins=512, range=(ndvi_hist_min, ndvi_hist_max))
+plt.title("NDVI Histogram")
+plt.show()
+
+min_display_ndvi = 0.45 # further mask soil by removing low-ndvi values
+#min_display_ndvi = np.percentile(ndvi.flatten(), 5.0) # modify with these percentilse to adjust contrast
+max_display_ndvi = np.percentile(ndvi.flatten(), 99.5) # for many images, 0.5 and 99.5 are good values
+masked_ndvi = np.ma.masked_where(ndvi < min_display_ndvi, ndvi)
+
+#reduce the figure size to account for colorbar
+figsize=np.asarray(figsize) - np.array([3,2])
+
+#plot NDVI over an RGB basemap, with a colorbar showing the NDVI scale
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndvi,
+ figsize = figsize,
+ title = 'NDVI filtered to only plants over RGB base layer',
+ vmin = min_display_ndvi,
+ vmax = max_display_ndvi)
+fig.savefig('ndvi_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NDRE Computation¶
In the same manner, we can compute, filter, and display another index useful for the RedEdge camera, the Normalized Difference Red Edge (NDRE) index. We also filter out shadows and soil to ensure our display focuses only on the plant health.
+ +
+
+
+
+
+
+
+
+
+In [10]:
+
+
+
+
+
+
+# Compute Normalized Difference Red Edge Index from the NIR(3) and RedEdge(4) bands
+rededge_band = [name.lower() for name in capture.band_names()].index('red edge')
+ndre = (im_aligned[:,:,nir_band] - im_aligned[:,:,rededge_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,rededge_band])
+
+# Mask areas with shadows and low NDVI to remove soil
+masked_ndre = np.ma.masked_where(ndvi < min_display_ndvi, ndre)
+
+# Compute a histogram
+ndre_hist_min = np.min(masked_ndre)
+ndre_hist_max = np.max(masked_ndre)
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(masked_ndre.ravel(), bins=512, range=(ndre_hist_min, ndre_hist_max))
+plt.title("NDRE Histogram (filtered to only plants)")
+plt.show()
+
+min_display_ndre = np.percentile(masked_ndre, 5)
+max_display_ndre = np.percentile(masked_ndre, 99.5)
+
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndre,
+ figsize=figsize,
+ title='NDRE filtered to only plants over RGB base layer',
+ vmin=min_display_ndre,vmax=max_display_ndre)
+fig.savefig('ndre_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Red vs NIR Reflectance¶
Finally, we show a classic agricultural remote sensing output in the tassled cap plot. This plot can be useful for visualizing row crops and plots the Red Reflectance channel on the X-axis against the NIR reflectance channel on the Y-axis. This plot also clearly shows the line of the soil in that space. The tassled cap view isn't very useful for this arid data set; however, we can see the "badge of trees" of high NIR reflectance and relatively low red reflectance. This provides an example of one of the uses of aligned images for single capture analysis.
+ +
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+x_band = red_band
+y_band = nir_band
+x_max = np.max(im_aligned[:,:,x_band])
+y_max = np.max(im_aligned[:,:,y_band])
+
+fig = plt.figure(figsize=(12,12))
+plt.hexbin(im_aligned[:,:,x_band],im_aligned[:,:,y_band],gridsize=640,bins='log',extent=(0,x_max,0,y_max))
+ax = fig.gca()
+ax.set_xlim([0,x_max])
+ax.set_ylim([0,y_max])
+plt.xlabel("{} Reflectance".format(capture.band_names()[x_band]))
+plt.ylabel("{} Reflectance".format(capture.band_names()[y_band]))
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Print warp_matrices for usage elsewhere, such as Batch Processing¶
Last, we output the warp_matrices that we got for this image stack for usage elsewhere. Currently these can be used in the Batch Processing.ipynb notebook to save reflectance-compensated stacks of images to a directory.
+
+
+
+
+
+
+
+
+In [12]:
+
+
+
+
+
+
+print(warp_matrices)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[array([[ 9.7928989e-01, 1.3615261e-04, 1.9574374e-02], + [-3.7023663e-03, 9.9245304e-01, 2.8355631e+01], + [-1.0651237e-05, 2.6095395e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9525303e-01, -7.0169556e-04, -6.3409243e+00], + [-7.1914408e-05, 9.9811482e-01, -6.2239196e-02], + [-3.6460631e-06, 1.8568957e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9596852e-01, -2.5820474e-03, -1.2950540e+01], + [ 2.8751660e-03, 9.9919146e-01, 2.6645420e+01], + [-1.8280600e-06, 2.3902323e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9592507e-01, 4.5777867e-03, 1.4982515e+01], + [-3.4031910e-03, 9.9773425e-01, 2.2611160e+01], + [-9.0995320e-07, 2.3299665e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0000000e+00, 2.8202797e-20, 8.9091027e-15], + [-5.6938062e-19, 1.0000000e+00, 6.4872178e-15], + [-1.2599002e-21, 1.3424955e-23, 1.0000000e+00]], dtype=float32), array([[ 9.9348122e-01, -1.8129036e-02, 1.1003100e+00], + [ 1.2132729e-02, 9.9091125e-01, 2.8742294e+01], + [-2.9285566e-06, -6.2816152e-06, 1.0000000e+00]], dtype=float32), array([[ 9.8954433e-01, -1.8810771e-02, 1.1892141e+01], + [ 1.3862181e-02, 9.8975760e-01, 2.0044521e+01], + [-4.0683108e-06, -4.2664565e-06, 1.0000000e+00]], dtype=float32), array([[ 9.8794365e-01, -1.2153405e-02, 1.8298512e+01], + [ 8.4343022e-03, 9.8829275e-01, 2.8633160e+01], + [-2.5430195e-06, -3.1491891e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9505156e-01, -1.7393423e-02, 3.6898847e+00], + [ 1.3367594e-02, 9.9287426e-01, 1.8703876e+01], + [-1.3000300e-06, -4.7085673e-06, 1.0000000e+00]], dtype=float32), array([[ 9.9182397e-01, -1.2042225e-02, 1.2686370e+01], + [ 7.6934961e-03, 9.8897797e-01, 2.7970253e+01], + [-9.2655773e-07, -6.0620891e-06, 1.0000000e+00]], dtype=float32)] ++
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Alignment-RigRelatives.html b/docs/Alignment-RigRelatives.html
new file mode 100644
index 00000000..28d0d21a
--- /dev/null
+++ b/docs/Alignment-RigRelatives.html
@@ -0,0 +1,15397 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2018 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+Passive Image Alignment¶
This workbook shows a completely passive alignment function using only the RigRelatives present in image metadata. Older versions of firmware may not include these tags. If your images don't, check the MicaSense support site for some tips on how to update your camera firmware to have them, as well as how to add them to datasets prior to the update.
+While this method doesn't provide perfect alignment, it can be fast and very useful for visualization of images when processing power is limited or speed is more important than alignment quality.
+Opening Images¶
As we have done in previous examples, we use the micasense.capture class to open, radiometrically correct, and visualize the 5 bands of a RedEdge capture.
+First, we'll load the autoreload extension. This lets us change underlying code (such as library functions) without having to reload the entire workbook and kernel. This is useful in this workbook because the cell that runs the alignment can take a long time to run, so with autoreload extension we can change external code for analysis and visualization without needing to re-compute the alignments each time.
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+import os, glob
+import micasense.capture as capture
+%matplotlib inline
+from pathlib import Path
+
+panelNames = None
+
+# This is an Altum image with RigRelatives and a thermal band
+
+imagePath = Path("./data/ALTUM")
+
+# these will return lists of image paths as strings
+imageNames = list(imagePath.glob('IMG_0021_*.tif'))
+imageNames = [x.as_posix() for x in imageNames]
+
+panelNames = list(imagePath.glob('IMG_0000_*.tif'))
+panelNames = [x.as_posix() for x in panelNames]
+
+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:
+ panel_reflectance_by_band = [0.49, 0.49, 0.49, 0.49, 0.49] #RedEdge band_index order
+ 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()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Alignment - Rig Relatives¶
For images with RigRelative tags present, we can find a rough alignment using only the built in relatives. These can be good for quick visualizatoins. For better results, use an algorithm like that in the other image alignment tutorial to sweeten the alignment.
+ +
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import micasense.imageutils as imageutils
+import micasense.plotutils as plotutils
+
+reference_band = 5
+warp_mode = cv2.MOTION_HOMOGRAPHY
+warp_matrices = capture.get_warp_matrices(ref_index=reference_band)
+
+cropped_dimensions,edges = imageutils.find_crop_bounds(capture,warp_matrices,reference_band=reference_band)
+im_aligned = imageutils.aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, reference_band, img_type=img_type)
+
+print(im_aligned.shape)
+
+print("warp_matrices={}".format(warp_matrices))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(91, 123, 6) +warp_matrices=[array([[ 1.57521370e+01, 2.64721217e-01, -2.44963917e+02], + [-2.94310824e-01, 1.58442787e+01, -1.34414613e+02], + [-2.77775663e-05, -9.67369561e-06, 1.00000000e+00]]), array([[ 1.55968786e+01, 2.34242421e-01, -2.26810378e+02], + [-2.78826529e-01, 1.56989040e+01, -1.13524137e+02], + [-4.23356370e-05, -1.27338303e-05, 1.00000000e+00]]), array([[ 1.56259258e+01, 3.15964099e-01, -1.90938966e+02], + [-3.41730559e-01, 1.57251597e+01, -9.97306451e+01], + [-2.77625565e-05, -5.27840773e-06, 1.00000000e+00]]), array([[ 1.56569908e+01, 2.40978299e-01, -2.27165074e+02], + [-2.94899115e-01, 1.57570534e+01, -1.33111975e+02], + [-4.09540877e-05, -2.33779890e-05, 1.00000000e+00]]), array([[ 1.55950891e+01, 2.07864879e-01, -2.33521065e+02], + [-2.85249968e-01, 1.56841110e+01, -1.31908090e+02], + [-5.30525636e-05, -3.78432070e-05, 1.00000000e+00]]), array([[1.00000000e+00, 1.02405070e-18, 0.00000000e+00], + [1.09972007e-18, 1.00000000e+00, 0.00000000e+00], + [1.60052412e-21, 8.52545510e-23, 1.00000000e+00]])] ++
+
+
+
+
+
+
+
+
+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. Usef ul componsites are a naturally colored RGB as well as color infrared, or CIR.
+ +
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+# figsize=(30,23) # use this size for full-image-resolution display
+figsize=(16,13) # use this size for export-sized display
+
+rgb_band_indices = [2,1,0]
+cir_band_indices = [3,2,1]
+
+# Create an empty normalized stack for viewing
+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[:,:,0:2].flatten(), 0.1) # modify with these percentilse to adjust contrast
+im_max = np.percentile(im_aligned[:,:,0:2].flatten(), 99.9) # for many images, 0.5 and 99.5 are good values
+
+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]
+# for cir false color imagery, we normalize the NIR,R,G bands within themselves, which provides
+# the classical CIR rendering where plants are red and soil takes on a blue tint
+for i in cir_band_indices:
+ im_display[:,:,i] = imageutils.normalize(im_aligned[:,:,i])
+
+cir = im_display[:,:,cir_band_indices]
+fig, axes = plt.subplots(1, 2, figsize=figsize)
+axes[0].set_title("Red-Green-Blue Composite")
+axes[0].imshow(rgb)
+axes[1].set_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 [5]:
+
+
+
+
+
+
+# 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.4
+gamma_corr_rgb = unsharp_rgb**(1.0/gamma)
+fig = plt.figure(figsize=figsize)
+plt.imshow(gamma_corr_rgb, aspect='equal')
+plt.axis('off')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rendered Image output¶
We can output the image to a PNG or JPEG file for viewing. This can also be useful in creating thumbnails of captures.
+ +
+
+
+
+
+
+
+
+
+In [6]:
+
+
+
+
+
+
+import imageio
+imtype = 'png' # or 'jpg'
+imageio.imwrite('rgb.'+imtype, (255*gamma_corr_rgb).astype('uint8'))
+
+
+
+
+
+
+
+
+
+Stack Export¶
We can export the image easily stacks using the gdal library (http://www.glal.org). Once exported, these image stacks can be opened in software such as QGIS and raster operations such as NDVI or NDRE computation can be done in that software. At this time the stacks don't include any geographic information.
+
+
+
+
+
+
+
+
+In [7]:
+
+
+
+
+
+
+from osgeo import gdal, gdal_array
+rows, cols, bands = im_display.shape
+driver = gdal.GetDriverByName('GTiff')
+filename = "bgrne" #blue,green,red,nir,redEdge
+
+if im_aligned.shape[2] == 6:
+ filename = filename + "t" #thermal
+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
+
+
+
+
+
+
+
+
+
+
+Notes on Alignment and Stack Usage¶
"Stacks" as described above are useful in a number of processing cases. For example, at the time of this writing, many photogrammetry suites could import and process stack files without significantly impacting the radiometric processing which has already been accomplished.
+Running photogrammetry on stack files instead of raw image files has both advantages and drawbacks. The primary advantage has been found to be an increase in processing speed and a reduction in program memory usage. As the photogrammetric workflow generally operates on luminance images and may not use color information, stacked images may require similar resources and be processed at a similar speed as single-band images. This is because one band of the stack can be used to generate the matching feature space while the others are ignored for matching purposes. This reduces the feature space 5-fold over matching using all images separately.
+One disadvantage is that stacking images outside of the photogrammetric workflow may result in poor image matching. The RedEdge is known to have stable lens characteristics over the course of normal operation, but variations in temperature or impacts to the camera through handling or rough landings may change the image alignment parameters. For this reason, we recommend finding a matching transformation for each flight (each take-off and landing). Alignment transformations from multiple images within a flight can be compared to find the best transformation to apply to the set of the flight. While not described or supported in this generic implementation, some matching algorithms can use a "seed" value as a starting point to speed up matching. For most cases, this seed could be the transformation found in a previous flight, or another source of a known good transformation.
+ +
+
+
+
+
+
+
+
+
+NDVI Computation¶
For raw index computation on single images, the numpy package provides a simple way to do math and simple visualizatoin on images. Below, we compute and visualize an image histogram and then use that to pick a colormap range for visualizing the NDVI of an image.
+Plant Classification¶
After computing the NDVI and prior to displaying it, we use a very rudimentary method for focusing on the plants and removing the soil and shadow information from our images and histograms. Below we remove non-plant pixels by setting to zero any pixels in the image where the NIR reflectance is less than 20%. This helps to ensure that the NDVI and NDRE histograms aren't skewed substantially by soil noise.
+ +
+
+
+
+
+
+
+
+
+In [8]:
+
+
+
+
+
+
+from micasense import plotutils
+import matplotlib.pyplot as plt
+
+np.seterr(divide='ignore', invalid='ignore') # ignore divide by zero errors in the index calculation
+
+# Compute Normalized Difference Vegetation Index (NDVI) from the NIR(3) and RED (2) bands
+ndvi = (im_aligned[:,:,3] - im_aligned[:,:,2]) / (im_aligned[:,:,3] + im_aligned[:,:,2])
+
+# remove shadowed areas (mask pixels with NIR reflectance < 20%))
+if img_type == 'reflectance':
+ ndvi = np.ma.masked_where(im_aligned[:,:,3] < 0.20, ndvi)
+elif img_type == 'radiance':
+ lower_pct_radiance = np.percentile(im_aligned[:,:,3], 10.0)
+ ndvi = np.ma.masked_where(im_aligned[:,:,3] < lower_pct_radiance, ndvi)
+
+# Compute and display a histogram
+ndvi_hist_min = np.min(ndvi)
+ndvi_hist_max = np.max(ndvi)
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(ndvi.ravel(), bins=512, range=(ndvi_hist_min, ndvi_hist_max))
+plt.title("NDVI Histogram")
+plt.show()
+
+min_display_ndvi = 0.45 # further mask soil by removing low-ndvi values
+#min_display_ndvi = np.percentile(ndvi.flatten(), 5.0) # modify with these percentilse to adjust contrast
+max_display_ndvi = np.percentile(ndvi.flatten(), 99.5) # for many images, 0.5 and 99.5 are good values
+masked_ndvi = np.ma.masked_where(ndvi < min_display_ndvi, ndvi)
+
+#reduce the figure size to account for colorbar
+figsize=np.asarray(figsize) - np.array([3,2])
+
+#plot NDVI over an RGB basemap, with a colorbar showing the NDVI scale
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndvi,
+ figsize = figsize,
+ title = 'NDVI filtered to only plants over RGB base layer',
+ vmin = min_display_ndvi,
+ vmax = max_display_ndvi)
+fig.savefig('ndvi_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NDRE Computation¶
In the same manner, we can compute, filter, and display another index useful for the RedEdge camera, the Normalized Difference Red Edge (NDRE) index. We also filter out shadows and soil to ensure our display focuses only on the plant health.
+ +
+
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+# Compute Normalized Difference Red Edge Index from the NIR(3) and RedEdge(4) bands
+ndre = (im_aligned[:,:,3] - im_aligned[:,:,4]) / (im_aligned[:,:,3] + im_aligned[:,:,4])
+
+# Mask areas with shadows and low NDVI to remove soil
+masked_ndre = np.ma.masked_where(ndvi < min_display_ndvi, ndre)
+
+# Compute a histogram
+ndre_hist_min = np.min(masked_ndre)
+ndre_hist_max = np.max(masked_ndre)
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(masked_ndre.ravel(), bins=512, range=(ndre_hist_min, ndre_hist_max))
+plt.title("NDRE Histogram (filtered to only plants)")
+plt.show()
+
+min_display_ndre = np.percentile(masked_ndre, 5)
+max_display_ndre = np.percentile(masked_ndre, 99.5)
+
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndre,
+ figsize=figsize,
+ title='NDRE filtered to only plants over RGB base layer',
+ vmin=min_display_ndre,vmax=max_display_ndre)
+fig.savefig('ndre_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Thermal Imagery¶
If our image is from an Altum and includes a thermal band, we can display the re-sampled and aligned thermal data over the RGB data to maintain the context of the thermal information.
+In the image below, it's very clear based on the average temperature where the soil is wet and dry, and even in the middle of the road we can find some wetter areas of soil.
+ +
+
+
+
+
+
+
+
+
+In [10]:
+
+
+
+
+
+
+if im_aligned.shape[2] >= 5:
+
+ # by default we don't mask the thermal, since it's native resolution is much lower than the MS
+ masked_thermal = im_aligned[:,:,5]
+ # Alternatively we can mask the thermal only to plants here, which is useful for large contiguous areas
+ # masked_thermal = np.ma.masked_where(ndvi < 0.45, im_aligned[:,:,5])
+
+
+ # Compute a histogram
+ fig, axis = plt.subplots(1, 1, figsize=(10,4))
+ axis.hist(masked_thermal.ravel(), bins=512, range=(np.min(masked_thermal), np.max(masked_thermal)))
+ plt.title("Thermal Histogram")
+ plt.show()
+
+ min_display_therm = np.percentile(masked_thermal, 1)
+ max_display_therm = np.percentile(masked_thermal, 99)
+
+ fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ 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")
+ fig.savefig('thermal_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Alignment.html b/docs/Alignment.html
new file mode 100644
index 00000000..1de3d1c8
--- /dev/null
+++ b/docs/Alignment.html
@@ -0,0 +1,15551 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+Active Image Alignment¶
In most use cases, each band of a multispectral capture must be aligned with the other bands in order to create meaningful data. In this tutorial, we show how to align the band to each other using open source OpenCV utilities.
+Image alignment allows the combination of images into true-color (RGB) and false color (such as CIR) composites, useful for scouting using single images as well as for display and management uses. In addition to composite images, alignment allows the calculation of pixel-accurate indices such as NDVI or NDRE at the single image level which can be very useful for applications like plant counting and coverage estimations, where mosaicing artifacts may otherwise skew analysis results.
+The image alignment method described below tends to work well on images with abundant image features, or areas of significant contrast. Cars, buildings, parking lots, and roads tend to provide the best results. This approach may not work well on images which contain few features or very repetitive features, such as full canopy row crops or fields of repetitive small crops such lettuce or strawberries. We will disscuss more about the advantages and disadvantages of these methods below.
+The functions behind this alignment process can work with most versions of RedEdge and Altum firmware. They will work best with versions above 3.2.0 which include the "RigRelatives" tags. These tags provide a starting point for the image transformation and can help to ensure convergence of the algorithm.
+Opening Images¶
As we have done in previous examples, we use the micasense.capture class to open, radiometrically correct, and visualize the 5 bands of a RedEdge capture.
+First, we'll load the autoreload extension. This lets us change underlying code (such as library functions) without having to reload the entire workbook and kernel. This is useful in this workbook because the cell that runs the alignment can take a long time to run, so with autoreload extension we can update the code after the alignment step for analysis and visualization without needing to re-compute the alignments each time.
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+import os, glob
+import micasense.capture as capture
+%matplotlib inline
+from pathlib import Path
+import matplotlib.pyplot as plt
+plt.rcParams["figure.facecolor"] = "w"
+
+panelNames = None
+
+imagePath = Path("./data/REDEDGE-MX")
+
+# these will return lists of image paths as strings
+imageNames = list(imagePath.glob('IMG_0020_*.tif'))
+imageNames = [x.as_posix() for x in imageNames]
+
+panelNames = list(imagePath.glob('IMG_0001_*.tif'))
+panelNames = [x.as_posix() for x in panelNames]
+
+# 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.49, 0.49, 0.49, 0.49, 0.49] #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()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Unwarp and Align¶
Alignment is a three step process:
+-
+
- Images are unwarped using the built-in lens calibration +
- A transformation is found to align each band to a common band +
- The aligned images are combined and cropped, removing pixels which don't overlap in all bands. +
We provide utilities to find the alignement transformations within a single capture. Our experience shows that once a good alignmnet transformation is found, it tends to be stable over a flight and, in most cases, over many flights. The transformation may change if the camera undergoes a shock event (such as a hard landing or drop) or if the temperature changes substantially between flights. In these events a new transformation may need to be found.
+Further, since this approach finds a 2-dimensional (affine) transformation between images, it won't work when the parallax between bands results in a 3-dimensional depth field. This can happen if very close to the target or when targets are visible at significantly different ranges, such as a nearby tree or building against a background much farther way. In these cases it will be necessary to use photogrammetry techniques to find a 3-dimensional mapping between images.
+For best alignment results it's good to select a capture which has features which visible in all bands. Man-made objects such as cars, roads, and buildings tend to work very well, while captures of only repeating crop rows tend to work poorly. Remember, once a good transformation has been found for flight, it can be generally be applied across all of the images.
+It's also good to use an image for alignment which is taken near the same level above ground as the rest of the flights. Above approximately 35m AGL, the alignement will be consistent. However, if images taken closer to the ground are used, such as panel images, the same alignment transformation will not work for the flight data.
+ +
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import micasense.imageutils as imageutils
+import micasense.plotutils as plotutils
+
+## 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)
+
+print("Finished Aligning, warp matrices={}".format(warp_matrices))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Aligning images. Depending on settings this can take from a few seconds to many minutes +Finished aligning band 1 +Finished aligning band 2 +Finished aligning band 4 +Finished aligning band 0 +Finished aligning band 3 +Finished Aligning, warp matrices=[array([[ 1.0109243e+00, 1.3997733e-03, 7.1472993e+00], + [ 2.3857178e-03, 1.0134553e+00, -1.1758372e+01], + [ 1.2079964e-06, 4.8187062e-06, 1.0000000e+00]], dtype=float32), array([[1.0000000e+00, 0.0000000e+00, 1.1368684e-13], + [0.0000000e+00, 1.0000000e+00, 0.0000000e+00], + [0.0000000e+00, 0.0000000e+00, 1.0000000e+00]], dtype=float32), array([[ 1.0093619e+00, 3.3198819e-03, -3.2410549e+01], + [ 8.4111997e-04, 1.0132477e+00, 1.3615667e+01], + [-4.9676191e-07, 7.0111369e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0142691e+00, 6.4295256e-03, -2.3179104e+01], + [ 4.6660731e-05, 1.0160753e+00, -1.2280207e+01], + [ 2.7585847e-06, 7.7613631e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0161121e+00, 2.1327983e-03, -2.0565905e+01], + [ 1.3823286e-03, 1.0168507e+00, -6.6128030e+00], + [ 2.2218899e-06, 3.5776138e-06, 1.0000000e+00]], dtype=float32)] ++
+
+
+
+
+
+
+
+
+Crop Aligned Images¶
After finding image alignments we may need to remove pixels around the edges which aren't present in every image in the capture. To do this we use the affine transforms found above and the image distortions from the image metadata. OpenCV provides a couple of handy helpers for this task in the cv2.undistortPoints() and cv2.transform() methods. These methods takes a set of pixel coordinates and apply our undistortion matrix and our affine transform, respectively. So, just as we did when registering the images, we first apply the undistortion process the coordinates of the image borders, then we apply the affine transformation to that result. The resulting pixel coordinates tell us where the image borders end up after this pair of transformations, and we can then crop the resultant image to these coordinates.
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+cropped_dimensions, edges = imageutils.find_crop_bounds(capture, warp_matrices, warp_mode=warp_mode, reference_band=match_index)
+print(cropped_dimensions)
+im_aligned = imageutils.aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type=img_type)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(35.0, 19.0, 1222.0, 912.0) ++
+
+
+
+
+
+
+
+
+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. Usef ul componsites are a naturally colored RGB as well as color infrared, or CIR.
+ +
+
+
+
+
+
+
+
+
+In [5]:
+
+
+
+
+
+
+# figsize=(30,23) # use this size for full-image-resolution display
+figsize=(16,13) # use this size for export-sized display
+
+rgb_band_indices = [capture.band_names_lower().index('red'),
+ capture.band_names_lower().index('green'),
+ capture.band_names_lower().index('blue')]
+cir_band_indices = [capture.band_names_lower().index('nir'),
+ capture.band_names_lower().index('red'),
+ capture.band_names_lower().index('green')]
+
+# 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 )
+
+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 rgb true color, we use the same min and max scaling across the 3 bands to
+# maintain the "white balance" of the calibrated image
+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 cir false color imagery, we normalize the NIR,R,G bands within themselves, which provides
+# the classical CIR rendering where plants are red and soil takes on a blue tint
+for i in cir_band_indices:
+ im_display[:,:,i] = imageutils.normalize(im_aligned[:,:,i])
+
+cir = im_display[:,:,cir_band_indices]
+fig, axes = plt.subplots(1, 2, figsize=figsize)
+axes[0].set_title("Red-Green-Blue Composite")
+axes[0].imshow(rgb)
+axes[1].set_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 [6]:
+
+
+
+
+
+
+# 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.4
+gamma_corr_rgb = unsharp_rgb**(1.0/gamma)
+fig = plt.figure(figsize=figsize)
+plt.imshow(gamma_corr_rgb, aspect='equal')
+plt.axis('off')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Image Export¶
Composite images can be exported to JPEG or PNG format using the imageio package. These images may be useful for visualization or thumbnailing, and creating RGB thumbnails of a set of images can provide a convenient way to browse the imagery in a more visually appealing way that browsing the raw imagery.
+
+
+
+
+
+
+
+
+In [7]:
+
+
+
+
+
+
+import imageio
+imtype = 'png' # or 'jpg'
+imageio.imwrite('rgb.'+imtype, (255*gamma_corr_rgb).astype('uint8'))
+imageio.imwrite('cir.'+imtype, (255*cir).astype('uint8'))
+
+
+
+
+
+
+
+
+
+Stack Export¶
We can export the image easily stacks using the gdal library (http://www.glal.org). Once exported, these image stacks can be opened in software such as QGIS and raster operations such as NDVI or NDRE computation can be done in that software. At this time the stacks don't include any geographic information.
+
+
+
+
+
+
+
+
+In [8]:
+
+
+
+
+
+
+from osgeo import gdal, gdal_array
+rows, cols, bands = im_display.shape
+driver = gdal.GetDriverByName('GTiff')
+filename = "bgrne" #blue,green,red,nir,redEdge
+
+if im_aligned.shape[2] == 6:
+ filename = filename + "t" #thermal
+outRaster = driver.Create(filename+"B.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
+
+
+
+
+
+
+
+
+
+
+Notes on Alignment and Stack Usage¶
"Stacks" as described above are useful in a number of processing cases. For example, at the time of this writing, many photogrammetry suites could import and process stack files without significantly impacting the radiometric processing which has already been accomplished.
+Running photogrammetry on stack files instead of raw image files has both advantages and drawbacks. The primary advantage has been found to be an increase in processing speed and a reduction in program memory usage. As the photogrammetric workflow generally operates on luminance images and may not use color information, stacked images may require similar resources and be processed at a similar speed as single-band images. This is because one band of the stack can be used to generate the matching feature space while the others are ignored for matching purposes. This reduces the feature space 5-fold over matching using all images separately.
+One disadvantage is that stacking images outside of the photogrammetric workflow may result in poor image matching. The RedEdge is known to have stable lens characteristics over the course of normal operation, but variations in temperature or impacts to the camera through handling or rough landings may change the image alignment parameters. For this reason, we recommend finding a matching transformation for each flight (each take-off and landing). Alignment transformations from multiple images within a flight can be compared to find the best transformation to apply to the set of the flight. While not described or supported in this generic implementation, some matching algorithms can use a "seed" value as a starting point to speed up matching. For most cases, this seed could be the transformation found in a previous flight, or another source of a known good transformation.
+ +
+
+
+
+
+
+
+
+
+NDVI Computation¶
For raw index computation on single images, the numpy package provides a simple way to do math and simple visualizatoin on images. Below, we compute and visualize an image histogram and then use that to pick a colormap range for visualizing the NDVI of an image.
+Plant Classification¶
After computing the NDVI and prior to displaying it, we use a very rudimentary method for focusing on the plants and removing the soil and shadow information from our images and histograms. Below we remove non-plant pixels by setting to zero any pixels in the image where the NIR reflectance is less than 20%. This helps to ensure that the NDVI and NDRE histograms aren't skewed substantially by soil noise.
+ +
+
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+from micasense import plotutils
+import matplotlib.pyplot as plt
+
+nir_band = capture.band_names_lower().index('nir')
+red_band = capture.band_names_lower().index('red')
+
+np.seterr(divide='ignore', invalid='ignore') # ignore divide by zero errors in the index calculation
+
+# Compute Normalized Difference Vegetation Index (NDVI) from the NIR(3) and RED (2) bands
+ndvi = (im_aligned[:,:,nir_band] - im_aligned[:,:,red_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,red_band])
+
+# remove shadowed areas (mask pixels with NIR reflectance < 20%))
+if img_type == 'reflectance':
+ ndvi = np.ma.masked_where(im_aligned[:,:,nir_band] < 0.20, ndvi)
+elif img_type == 'radiance':
+ lower_pct_radiance = np.percentile(im_aligned[:,:,3], 10.0)
+ ndvi = np.ma.masked_where(im_aligned[:,:,nir_band] < lower_pct_radiance, ndvi)
+
+# Compute and display a histogram
+ndvi_hist_min = np.min(ndvi)
+ndvi_hist_max = np.max(ndvi)
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(ndvi.ravel(), bins=512, range=(ndvi_hist_min, ndvi_hist_max))
+plt.title("NDVI Histogram")
+plt.show()
+
+min_display_ndvi = 0.45 # further mask soil by removing low-ndvi values
+#min_display_ndvi = np.percentile(ndvi.flatten(), 5.0) # modify with these percentilse to adjust contrast
+max_display_ndvi = np.percentile(ndvi.flatten(), 99.5) # for many images, 0.5 and 99.5 are good values
+masked_ndvi = np.ma.masked_where(ndvi < min_display_ndvi, ndvi)
+
+#reduce the figure size to account for colorbar
+figsize=np.asarray(figsize) - np.array([3,2])
+
+#plot NDVI over an RGB basemap, with a colorbar showing the NDVI scale
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndvi,
+ figsize = figsize,
+ title = 'NDVI filtered to only plants over RGB base layer',
+ vmin = min_display_ndvi,
+ vmax = max_display_ndvi)
+fig.savefig('ndvi_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+NDRE Computation¶
In the same manner, we can compute, filter, and display another index useful for the RedEdge camera, the Normalized Difference Red Edge (NDRE) index. We also filter out shadows and soil to ensure our display focuses only on the plant health.
+ +
+
+
+
+
+
+
+
+
+In [10]:
+
+
+
+
+
+
+# Compute Normalized Difference Red Edge Index from the NIR(3) and RedEdge(4) bands
+rededge_band = capture.band_names_lower().index('red edge')
+ndre = (im_aligned[:,:,nir_band] - im_aligned[:,:,rededge_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,rededge_band])
+
+# Mask areas with shadows and low NDVI to remove soil
+masked_ndre = np.ma.masked_where(ndvi < min_display_ndvi, ndre)
+
+# Compute a histogram
+ndre_hist_min = np.min(masked_ndre)
+ndre_hist_max = np.max(masked_ndre)
+fig, axis = plt.subplots(1, 1, figsize=(10,4))
+axis.hist(masked_ndre.ravel(), bins=512, range=(ndre_hist_min, ndre_hist_max))
+plt.title("NDRE Histogram (filtered to only plants)")
+plt.show()
+
+min_display_ndre = np.percentile(masked_ndre, 5)
+max_display_ndre = np.percentile(masked_ndre, 99.5)
+
+fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ masked_ndre,
+ figsize=figsize,
+ title='NDRE filtered to only plants over RGB base layer',
+ vmin=min_display_ndre,vmax=max_display_ndre)
+fig.savefig('ndre_over_rgb.png')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Thermal Imagery¶
If our image is from an Altum and includes a thermal band, we can display the re-sampled and aligned thermal data over the RGB data to maintain the context of the thermal information.
+In the image below, it's very clear based on the average temperature where the soil is wet and dry, and even in the middle of the road we can find some wetter areas of soil.
+ +
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+if len(capture.lw_indices()) > 0:
+
+ # by default we don't mask the thermal, since it's native resolution is much lower than the MS
+ masked_thermal = im_aligned[:,:,5]
+ # Alternatively we can mask the thermal only to plants here, which is useful for large contiguous areas
+ # masked_thermal = np.ma.masked_where(ndvi < 0.45, im_aligned[:,:,5])
+
+
+ # Compute a histogram
+ fig, axis = plt.subplots(1, 1, figsize=(10,4))
+ axis.hist(masked_thermal.ravel(), bins=512, range=(np.min(masked_thermal), np.max(masked_thermal)))
+ plt.title("Thermal Histogram")
+ plt.show()
+
+ min_display_therm = np.percentile(masked_thermal, 1)
+ max_display_therm = np.percentile(masked_thermal, 99)
+
+ fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb,
+ 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")
+ fig.savefig('thermal_over_rgb.png')
+
+
+
+
+
+
+
+
+
+Red vs NIR Reflectance¶
Finally, we show a classic agricultural remote sensing output in the tassled cap plot. This plot can be useful for visualizing row crops and plots the Red Reflectance channel on the X-axis against the NIR reflectance channel on the Y-axis. This plot also clearly shows the line of the soil in that space. The tassled cap view isn't very useful for this arid data set; however, we can see the "badge of trees" of high NIR reflectance and relatively low red reflectance. This provides an example of one of the uses of aligned images for single capture analysis.
+ +
+
+
+
+
+
+
+
+
+In [12]:
+
+
+
+
+
+
+x_band = red_band
+y_band = nir_band
+x_max = np.max(im_aligned[:,:,x_band])
+y_max = np.max(im_aligned[:,:,y_band])
+
+fig = plt.figure(figsize=(12,12))
+plt.hexbin(im_aligned[:,:,x_band],im_aligned[:,:,y_band],gridsize=640,bins='log',extent=(0,x_max,0,y_max))
+ax = fig.gca()
+ax.set_xlim([0,x_max])
+ax.set_ylim([0,y_max])
+plt.xlabel("{} Reflectance".format(capture.band_names()[x_band]))
+plt.ylabel("{} Reflectance".format(capture.band_names()[y_band]))
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Print warp_matrices for usage elsewhere, such as Batch Processing¶
Last, we output the warp_matrices that we got for this image stack for usage elsewhere. Currently these can be used in the Batch Processing.ipynb notebook to save reflectance-compensated stacks of images to a directory.
+
+
+
+
+
+
+
+
+In [13]:
+
+
+
+
+
+
+print(warp_matrices)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[array([[ 1.0109243e+00, 1.3997733e-03, 7.1472993e+00], + [ 2.3857178e-03, 1.0134553e+00, -1.1758372e+01], + [ 1.2079964e-06, 4.8187062e-06, 1.0000000e+00]], dtype=float32), array([[1.0000000e+00, 0.0000000e+00, 1.1368684e-13], + [0.0000000e+00, 1.0000000e+00, 0.0000000e+00], + [0.0000000e+00, 0.0000000e+00, 1.0000000e+00]], dtype=float32), array([[ 1.0093619e+00, 3.3198819e-03, -3.2410549e+01], + [ 8.4111997e-04, 1.0132477e+00, 1.3615667e+01], + [-4.9676191e-07, 7.0111369e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0142691e+00, 6.4295256e-03, -2.3179104e+01], + [ 4.6660731e-05, 1.0160753e+00, -1.2280207e+01], + [ 2.7585847e-06, 7.7613631e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0161121e+00, 2.1327983e-03, -2.0565905e+01], + [ 1.3823286e-03, 1.0168507e+00, -6.6128030e+00], + [ 2.2218899e-06, 3.5776138e-06, 1.0000000e+00]], dtype=float32)] ++
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Batch Processing v2.html b/docs/Batch Processing v2.html
new file mode 100644
index 00000000..a0577a64
--- /dev/null
+++ b/docs/Batch Processing v2.html
@@ -0,0 +1,15707 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2018 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+Batch Processing Example¶
In this example, we use the micasense.imageset class to load a set of directories of images into a list of micasense.capture objects, and we iterate over that list, saving out each image as an aligned stack of images as separate bands in a single tiff file each. Part of this process (via imageutils.write_exif_to_stack) injects that the GPS, capture datetime, camera model, etc into the processed images, allowing us to stitch those images using commercial software such as Pix4DMapper or Agisoft Metashape.
Note: for this example to work, the images must have a valid RigRelatives tag. This requires RedEdge (3/M/MX) version of at least 3.4.0, or any version of RedEdge-P/Altum-PT/Altum/RedEdge-MX Dual. If your images don't meet that spec, you can also follow this support article to add the RigRelatives tag to your imagery: https://support.micasense.com/hc/en-us/articles/360006368574-Modifying-older-collections-for-Pix4Dfields-support
+ +
+
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+Load Images into ImageSet¶
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+from ipywidgets import FloatProgress, Layout
+from IPython.display import display
+import micasense.imageset as imageset
+import micasense.capture as capture
+import os, glob
+import multiprocessing
+from pathlib import Path
+
+# set to True if you have an Altum-PT
+# or RedEdge-P and wish to output pan-sharpened stacks
+panSharpen = True
+
+panelNames = None
+useDLS = True
+
+# set your image path here. See more here: https://docs.python.org/3/library/pathlib.html
+imagePath = Path("./data/REDEDGE-MX")
+
+# these will return lists of image paths as strings
+panelNames = list(imagePath.glob('IMG_0001_*.tif'))
+panelNames = [x.as_posix() for x in panelNames]
+
+panelCap = capture.Capture.from_filelist(panelNames)
+
+# destinations on your computer to put the stacks
+# and RGB thumbnails
+outputPath = imagePath / '..' / 'stacks'
+thumbnailPath = outputPath / 'thumbnails'
+
+cam_model = panelCap.camera_model
+cam_serial = panelCap.camera_serial
+
+# determine if this sensor has a panchromatic band
+if cam_model == 'RedEdge-P' or cam_model == 'Altum-PT':
+ panchroCam = True
+else:
+ panchroCam = False
+ panSharpen = False
+
+# if this is a multicamera system like the RedEdge-MX Dual,
+# we can combine the two serial numbers to help identify
+# this camera system later.
+if len(panelCap.camera_serials) > 1:
+ cam_serial = "_".join(panelCap.camera_serials)
+ print("Serial number:",cam_serial)
+else:
+ cam_serial = panelCap.camera_serial
+ print("Serial number:",cam_serial)
+
+overwrite = False # can be set to set to False to continue interrupted processing
+generateThumbnails = True
+
+# Allow this code to align both radiance and reflectance images; but 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
+
+if panelCap is not None:
+ if panelCap.panel_albedo() is not None and not any(v is None for v in panelCap.panel_albedo()):
+ panel_reflectance_by_band = panelCap.panel_albedo()
+ else:
+ panel_reflectance_by_band = [0.49]*len(panelCap.eo_band_names()) #RedEdge band_index order
+
+ panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band)
+ img_type = "reflectance"
+else:
+ if useDLS:
+ img_type='reflectance'
+ else:
+ img_type = "radiance"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Serial number: RX02-2023065-SC ++
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+## This progress widget is used for display of the long-running process
+f = FloatProgress(min=0, max=1, layout=Layout(width='100%'), description="Loading")
+display(f)
+def update_f(val):
+ if (val - f.value) > 0.005 or val == 1: #reduces cpu usage from updating the progressbar by 10x
+ f.value=val
+
+%time imgset = imageset.ImageSet.from_directory(imagePath, progress_callback=update_f)
+update_f(1.0)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CPU times: user 31.5 ms, sys: 7.14 ms, total: 38.6 ms +Wall time: 278 ms ++
+
+
+
+
+
+
+
+
+Capture map¶
We can map out the capture GPS locations to ensure we are processing the right data. A GeoJSON of the captures will later be saved to the outputPath.
+ +
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+import math
+import numpy as np
+from mapboxgl.viz import *
+from mapboxgl.utils import df_to_geojson, create_radius_stops, scale_between
+from mapboxgl.utils import create_color_stops
+import pandas as pd
+
+data, columns = imgset.as_nested_lists()
+df = pd.DataFrame.from_records(data, index='timestamp', columns=columns)
+
+#Insert your mapbox token here
+token = 'pk.eyJ1IjoibWljYXNlbnNlIiwiYSI6ImNqYWx5dWNteTJ3cWYzMnBicmZid3g2YzcifQ.Zrq9t7GYocBtBzYyT3P4sw'
+color_property = 'dls-yaw'
+num_color_classes = 8
+
+min_val = df[color_property].min()
+max_val = df[color_property].max()
+
+import jenkspy
+# breaks = jenkspy.jenks_breaks(df[color_property], nb_class=num_color_classes)
+
+# color_stops = create_color_stops(breaks,colors='YlOrRd')
+geojson_data = df_to_geojson(df,columns[3:],lat='latitude',lon='longitude')
+
+viz = CircleViz(geojson_data, access_token=token, color_property=color_property,
+# color_stops=color_stops,
+ center=[df['longitude'].median(),df['latitude'].median()],
+ zoom=16, height='600px',
+ style='mapbox://styles/mapbox/satellite-streets-v9')
+viz.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/Users/stephen/anaconda3/envs/micasense/lib/python3.7/site-packages/IPython/core/display.py:724: UserWarning: Consider using IPython.display.IFrame instead
+ warnings.warn("Consider using IPython.display.IFrame instead")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Define which warp method to use¶
For newer data sets with RigRelatives tags (images captured with RedEdge (3/M/MX) version 3.4.0 or greater with a valid calibration load, see https://support.micasense.com/hc/en-us/articles/360005428953-Updating-RedEdge-for-Pix4Dfields), we can use the RigRelatives for a simple alignment. To use this simple alignment, simply set warp_matrices=None
For sets without those tags, or sets that require a RigRelatives optimization, we can go through the Alignment.ipynb notebook and get a set of warp_matrices that we can use here to align.
+ +
+
+
+
+
+
+
+
+
+In [5]:
+
+
+
+
+
+
+from numpy import array
+from numpy import float32
+from skimage.transform import ProjectiveTransform
+
+if panchroCam:
+ warp_matrices_filename = cam_serial + "_warp_matrices_SIFT.npy"
+else:
+ warp_matrices_filename = cam_serial + "_warp_matrices_opencv.npy"
+
+if Path('./' + warp_matrices_filename).is_file():
+ print("Found existing warp matrices for camera", cam_serial)
+ load_warp_matrices = np.load(warp_matrices_filename, allow_pickle=True)
+ loaded_warp_matrices = []
+ for matrix in load_warp_matrices:
+ if panchroCam:
+ transform = ProjectiveTransform(matrix=matrix.astype('float64'))
+ loaded_warp_matrices.append(transform)
+ else:
+ loaded_warp_matrices.append(matrix.astype('float32'))
+
+ if panchroCam:
+ warp_matrices_SIFT = loaded_warp_matrices
+ else:
+ warp_matrices = loaded_warp_matrices
+ print("Loaded warp matrices from",Path('./' + warp_matrices_filename).resolve())
+else:
+ print("No warp matrices found at expected location:",warp_matrices_filename)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Found existing warp matrices for camera RX02-2023065-SC +Loaded warp matrices from /Users/stephen/programs/gitlab/imageProcessingTutorial/RX02-2023065-SC_warp_matrices_opencv.npy ++
+
+
+
+
+
+
+
+
+Align images and save each capture to a layered TIFF file¶
+
+
+
+
+
+
+
+
+In [6]:
+
+
+
+
+
+
+import exiftool
+import datetime
+## This progress widget is used for display of the long-running process
+f2 = FloatProgress(min=0, max=1, layout=Layout(width='100%'), description="Saving")
+display(f2)
+def update_f2(val):
+ f2.value=val
+
+if not os.path.exists(outputPath):
+ os.makedirs(outputPath)
+if generateThumbnails and not os.path.exists(thumbnailPath):
+ os.makedirs(thumbnailPath)
+
+# Save out geojson data so we can open the image capture locations in our GIS
+with open(os.path.join(outputPath,'imageSet.json'),'w') as f:
+ f.write(str(geojson_data))
+
+try:
+ irradiance = panel_irradiance+[0]
+except NameError:
+ irradiance = None
+
+start = datetime.datetime.now()
+for i,capture in enumerate(imgset.captures):
+ outputFilename = capture.uuid+'.tif'
+ thumbnailFilename = capture.uuid+'.jpg'
+ fullOutputPath = os.path.join(outputPath, outputFilename)
+ fullThumbnailPath= os.path.join(thumbnailPath, thumbnailFilename)
+ if (not os.path.exists(fullOutputPath)) or overwrite:
+ if(len(capture.images) == len(imgset.captures[0].images)):
+ if panchroCam:
+ capture.radiometric_pan_sharpened_aligned_capture(warp_matrices=warp_matrices_SIFT,irradiance_list=irradiance)
+ else:
+ capture.create_aligned_capture(irradiance_list=irradiance, warp_matrices=warp_matrices)
+ capture.save_capture_as_stack(fullOutputPath, pansharpen=panSharpen,sort_by_wavelength=False)
+ if generateThumbnails:
+ capture.save_capture_as_rgb(fullThumbnailPath)
+ capture.clear_image_data()
+ update_f2(float(i)/float(len(imgset.captures)))
+update_f2(1.0)
+end = datetime.datetime.now()
+
+print("Saving time: {}".format(end-start))
+print("Alignment+Saving rate: {:.2f} images per second".format(float(len(imgset.captures))/float((end-start).total_seconds())))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Saving time: 0:00:04.008601 +Alignment+Saving rate: 0.50 images per second ++
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Batch Processing.html b/docs/Batch Processing.html
new file mode 100644
index 00000000..9bd8a875
--- /dev/null
+++ b/docs/Batch Processing.html
@@ -0,0 +1,15747 @@
+
+
+
+
+
+
+
+
+
+
+
+
+In [ ]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Batch Processing Example¶
In this example, we use the micasense.imageset class to load a set of directories of images into a list of micasense.capture objects, and we iterate over that list saving out each image as an aligned stack of images as separate bands in a single tiff file each. Next, we use the metadata from the original captures to write out a log file of the captures and their locations. Finally, we use exiftool from the command line to inject that metadata into the processed images, allowing us to stitch those images using commercial software such as Pix4D or Agisoft.
Note: for this example to work, the images must have a valid RigRelatives tag. This requires RedEdge version of at least 3.4.0 or any version of Altum. If your images don't meet that spec, you can also follow this support ticket to add the RigRelatives tag to them: https://support.micasense.com/hc/en-us/articles/360006368574-Modifying-older-collections-for-Pix4Dfields-support
+ +
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+The autoreload extension is already loaded. To reload it, use: + %reload_ext autoreload ++
+
+
+
+
+
+
+
+
+Load Images into ImageSet¶
+
+
+
+
+
+
+
+
+In [6]:
+
+
+
+
+
+
+from ipywidgets import FloatProgress, Layout
+from IPython.display import display
+import micasense.imageset as imageset
+import micasense.capture as capture
+import os, glob
+import multiprocessing
+from pathlib import Path
+
+panelNames = None
+useDLS = True
+
+# set your image path here. See more here: https://docs.python.org/3/library/pathlib.html
+imagePath = Path("./data/REDEDGE-MX")
+
+# these will return lists of image paths as strings
+panelNames = list(imagePath.glob('IMG_0001_*.tif'))
+panelNames = [x.as_posix() for x in panelNames]
+
+panelCap = capture.Capture.from_filelist(panelNames)
+
+# destinations on your computer to put the stacks
+# and RGB thumbnails
+outputPath = imagePath / '..' / 'stacks'
+thumbnailPath = outputPath / 'thumbnails'
+
+overwrite = False # can be set to set to False to continue interrupted processing
+generateThumbnails = True
+
+# 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
+
+if panelCap is not None:
+ if panelCap.panel_albedo() is not None and not any(v is None for v in panelCap.panel_albedo()):
+ panel_reflectance_by_band = panelCap.panel_albedo()
+ else:
+ panel_reflectance_by_band = [0.49, 0.49, 0.49, 0.49, 0.49] #RedEdge band_index order
+
+ panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band)
+ img_type = "reflectance"
+else:
+ if useDLS:
+ img_type='reflectance'
+ else:
+ img_type = "radiance"
+
+
+
+
+
+
+
+
+In [7]:
+
+
+
+
+
+
+## This progress widget is used for display of the long-running process
+f = FloatProgress(min=0, max=1, layout=Layout(width='100%'), description="Loading")
+display(f)
+def update_f(val):
+ if (val - f.value) > 0.005 or val == 1: #reduces cpu usage from updating the progressbar by 10x
+ f.value=val
+
+%time imgset = imageset.ImageSet.from_directory(imagePath, progress_callback=update_f)
+update_f(1.0)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FloatProgress(value=0.0, description='Loading', layout=Layout(width='100%'), max=1.0)+
+
+
+
+
+
+
+
+
+
+CPU times: user 32.4 ms, sys: 10.3 ms, total: 42.8 ms +Wall time: 315 ms ++
+
+
+
+
+
+
+
+
+In [8]:
+
+
+
+
+
+
+import math
+import numpy as np
+from mapboxgl.viz import *
+from mapboxgl.utils import df_to_geojson, create_radius_stops, scale_between
+from mapboxgl.utils import create_color_stops
+import pandas as pd
+
+data, columns = imgset.as_nested_lists()
+df = pd.DataFrame.from_records(data, index='timestamp', columns=columns)
+
+#Insert your mapbox token here
+token = 'pk.eyJ1IjoibWljYXNlbnNlIiwiYSI6ImNqYWx5dWNteTJ3cWYzMnBicmZid3g2YzcifQ.Zrq9t7GYocBtBzYyT3P4sw'
+color_property = 'dls-yaw'
+num_color_classes = 8
+
+min_val = df[color_property].min()
+max_val = df[color_property].max()
+
+import jenkspy
+# breaks = jenkspy.jenks_breaks(df[color_property], nb_class=num_color_classes)
+
+# color_stops = create_color_stops(breaks,colors='YlOrRd')
+geojson_data = df_to_geojson(df,columns[3:],lat='latitude',lon='longitude')
+
+viz = CircleViz(geojson_data, access_token=token, color_property=color_property,
+# color_stops=color_stops,
+ center=[df['longitude'].median(),df['latitude'].median()],
+ zoom=16, height='600px',
+ style='mapbox://styles/mapbox/satellite-streets-v9')
+viz.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/Users/stephen/anaconda3/envs/micasense/lib/python3.7/site-packages/IPython/core/display.py:724: UserWarning: Consider using IPython.display.IFrame instead
+ warnings.warn("Consider using IPython.display.IFrame instead")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Define which warp method to use¶
For newer data sets with RigRelatives tags (images captured with RedEdge version 3.4.0 or greater with a valid calibration load, see https://support.micasense.com/hc/en-us/articles/360005428953-Updating-RedEdge-for-Pix4Dfields), we can use the RigRelatives for a simple alignment.
+For sets without those tags, or sets that require a RigRelatives optimization, we can go through the Alignment.ipynb notebook and get a set of warp_matrices that we can use here to align.
+
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+from numpy import array
+from numpy import float32
+
+# Set warp_matrices to none to align using RigRelatives
+# Or
+# Use the warp_matrices derived from the Alignment Tutorial for this RedEdge set without RigRelatives
+warp_matrices = [array([[ 1.0109243e+00, 1.3997733e-03, 7.1472993e+00],
+ [ 2.3857178e-03, 1.0134553e+00, -1.1758372e+01],
+ [ 1.2079964e-06, 4.8187062e-06, 1.0000000e+00]], dtype=float32), array([[1.0000000e+00, 0.0000000e+00, 1.1368684e-13],
+ [0.0000000e+00, 1.0000000e+00, 0.0000000e+00],
+ [0.0000000e+00, 0.0000000e+00, 1.0000000e+00]], dtype=float32), array([[ 1.0093619e+00, 3.3198819e-03, -3.2410549e+01],
+ [ 8.4111997e-04, 1.0132477e+00, 1.3615667e+01],
+ [-4.9676191e-07, 7.0111369e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0142691e+00, 6.4295256e-03, -2.3179104e+01],
+ [ 4.6660731e-05, 1.0160753e+00, -1.2280207e+01],
+ [ 2.7585847e-06, 7.7613631e-06, 1.0000000e+00]], dtype=float32), array([[ 1.0161121e+00, 2.1327983e-03, -2.0565905e+01],
+ [ 1.3823286e-03, 1.0168507e+00, -6.6128030e+00],
+ [ 2.2218899e-06, 3.5776138e-06, 1.0000000e+00]], dtype=float32)]
+
+
+
+
+
+
+
+
+
+Align images and save each capture to a layered tiff file¶
+
+
+
+
+
+
+
+
+
+In [10]:
+
+
+
+
+
+
+import exiftool
+import datetime
+## This progress widget is used for display of the long-running process
+f2 = FloatProgress(min=0, max=1, layout=Layout(width='100%'), description="Saving")
+display(f2)
+def update_f2(val):
+ f2.value=val
+
+if not os.path.exists(outputPath):
+ os.makedirs(outputPath)
+if generateThumbnails and not os.path.exists(thumbnailPath):
+ os.makedirs(thumbnailPath)
+
+# Save out geojson data so we can open the image capture locations in our GIS
+with open(os.path.join(outputPath,'imageSet.json'),'w') as f:
+ f.write(str(geojson_data))
+
+try:
+ irradiance = panel_irradiance+[0]
+except NameError:
+ irradiance = None
+
+start = datetime.datetime.now()
+for i,capture in enumerate(imgset.captures):
+ outputFilename = capture.uuid+'.tif'
+ thumbnailFilename = capture.uuid+'.jpg'
+ fullOutputPath = os.path.join(outputPath, outputFilename)
+ fullThumbnailPath= os.path.join(thumbnailPath, thumbnailFilename)
+ if (not os.path.exists(fullOutputPath)) or overwrite:
+ if(len(capture.images) == len(imgset.captures[0].images)):
+ capture.create_aligned_capture(irradiance_list=irradiance, warp_matrices=warp_matrices)
+ capture.save_capture_as_stack(fullOutputPath)
+ if generateThumbnails:
+ capture.save_capture_as_rgb(fullThumbnailPath)
+ capture.clear_image_data()
+ update_f2(float(i)/float(len(imgset.captures)))
+update_f2(1.0)
+end = datetime.datetime.now()
+
+print("Saving time: {}".format(end-start))
+print("Alignment+Saving rate: {:.2f} images per second".format(float(len(imgset.captures))/float((end-start).total_seconds())))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FloatProgress(value=0.0, description='Saving', layout=Layout(width='100%'), max=1.0)+
+
+
+
+
+
+
+
+
+
+Saving time: 0:00:05.053582 +Alignment+Saving rate: 0.40 images per second ++
+
+
+
+
+
+
+
+
+Extract Metadata from Captures list and save to log.csv¶
+
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+def decdeg2dms(dd):
+ is_positive = dd >= 0
+ dd = abs(dd)
+ minutes,seconds = divmod(dd*3600,60)
+ degrees,minutes = divmod(minutes,60)
+ degrees = degrees if is_positive else -degrees
+ return (degrees,minutes,seconds)
+
+header = "SourceFile,\
+GPSDateStamp,GPSTimeStamp,\
+GPSLatitude,GpsLatitudeRef,\
+GPSLongitude,GPSLongitudeRef,\
+GPSAltitude,GPSAltitudeRef,\
+FocalLength,\
+XResolution,YResolution,ResolutionUnits\n"
+
+lines = [header]
+for capture in imgset.captures:
+ #get lat,lon,alt,time
+ outputFilename = capture.uuid+'.tif'
+ fullOutputPath = os.path.join(outputPath, outputFilename)
+ lat,lon,alt = capture.location()
+ #write to csv in format:
+ # IMG_0199_1.tif,"33 deg 32' 9.73"" N","111 deg 51' 1.41"" W",526 m Above Sea Level
+ latdeg, latmin, latsec = decdeg2dms(lat)
+ londeg, lonmin, lonsec = decdeg2dms(lon)
+ latdir = 'North'
+ if latdeg < 0:
+ latdeg = -latdeg
+ latdir = 'South'
+ londir = 'East'
+ if londeg < 0:
+ londeg = -londeg
+ londir = 'West'
+ resolution = capture.images[0].focal_plane_resolution_px_per_mm
+
+ linestr = '"{}",'.format(fullOutputPath)
+ linestr += capture.utc_time().strftime("%Y:%m:%d,%H:%M:%S,")
+ linestr += '"{:d} deg {:d}\' {:.2f}"" {}",{},'.format(int(latdeg),int(latmin),latsec,latdir[0],latdir)
+ linestr += '"{:d} deg {:d}\' {:.2f}"" {}",{},{:.1f} m Above Sea Level,Above Sea Level,'.format(int(londeg),int(lonmin),lonsec,londir[0],londir,alt)
+ linestr += '{}'.format(capture.images[0].focal_length)
+ linestr += '{},{},mm'.format(resolution,resolution)
+ linestr += '\n' # when writing in text mode, the write command will convert to os.linesep
+ lines.append(linestr)
+
+fullCsvPath = os.path.join(outputPath,'log.csv')
+with open(fullCsvPath, 'w') as csvfile: #create CSV
+ csvfile.writelines(lines)
+
+
+
+
+
+
+
+
+
+Use Exiftool from the command line to write metadata to images¶
+
+
+
+
+
+
+
+
+In [14]:
+
+
+
+
+
+
+import subprocess
+
+if os.environ.get('exiftoolpath') is not None:
+ exiftool_cmd = os.path.normpath(os.environ.get('exiftoolpath'))
+else:
+ exiftool_cmd = 'exiftool'
+
+cmd = '{} -csv="{}" -overwrite_original "{}"'.format(exiftool_cmd, fullCsvPath, outputPath)
+print(cmd)
+subprocess.check_call(cmd, shell=True)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exiftool -csv="data/REDEDGE-MX/../stacks/log.csv" -overwrite_original "data/REDEDGE-MX/../stacks" ++
+
+
+
+
+
+
+
+
+
+1 directories scanned + 2 image files updated ++
+
+
+
+
+Out[14]:
+
+
+
+
+
+
+
+0+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Captures.html b/docs/Captures.html
new file mode 100644
index 00000000..070d6fcf
--- /dev/null
+++ b/docs/Captures.html
@@ -0,0 +1,14760 @@
+
+
+
+
+
+
+
+
+
+
+
+
+In [ ]:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Captures¶
A micasense.capture.Capture object holds a set of images (one per band) which are captured at the same moment together in a MicaSense camera. Files which meet this criteria will tend to have the same filename except for the suffix, but that is not required to load a captures. Captures can be loaded by starting with one image by calling Capture.from_file('file_name.tif') and adding others using the append_file, or by providing a list of filenames or images. See capture.py for more creation methods.
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+import os, glob
+import micasense.capture as capture
+%matplotlib inline
+
+imagePath = os.path.join('.','data','REDEDGE-MX')
+imageNames = glob.glob(os.path.join(imagePath,'IMG_0001_*.tif'))
+
+capture = capture.Capture.from_filelist(imageNames)
+capture.plot_raw()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+More Capture visualization functions¶
+
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+capture.plot_vignette();
+capture.plot_undistorted_radiance();
+capture.plot_panels()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/ImageSets.html b/docs/ImageSets.html
new file mode 100644
index 00000000..02c74b0f
--- /dev/null
+++ b/docs/ImageSets.html
@@ -0,0 +1,15632 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+ImageSet Extended Examples¶
A large group of images captured using a RedEdge over a central California orchard are available for download here.
+With this set extracted to a working folder, this notebook will load all of the images in the set and provide more usage examples of ImageSet data.
+Load a directory of images into an ImageSet¶
+
+
+
+
+
+
+
+
+In [ ]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+from ipywidgets import FloatProgress, Layout
+from IPython.display import display
+import micasense.imageset as imageset
+import os
+
+## This progress widget is used for display of the long-running process
+f = FloatProgress(min=0, max=1, layout=Layout(width='100%'), description="Loading")
+display(f)
+def update_f(val):
+ if (val - f.value) > 0.005 or val == 1: #reduces cpu usage from updating the progressbar by 10x
+ f.value=val
+
+images_dir = os.path.expanduser(os.path.join('.','data','REDEDGE-MX'))
+%time imgset = imageset.ImageSet.from_directory(images_dir, progress_callback=update_f)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FloatProgress(value=0.0, description='Loading', layout=Layout(width='100%'), max=1.0)+
+
+
+
+
+
+
+
+
+
+CPU times: user 33.4 ms, sys: 9.42 ms, total: 42.8 ms +Wall time: 304 ms ++
+
+
+
+
+
+
+
+
+Import Capture data into Pandas DataFrame¶
+
+
+
+
+
+
+
+
+
+In [12]:
+
+
+
+
+
+
+import pandas as pd
+data, columns = imgset.as_nested_lists()
+print("Columns: {}".format(columns))
+df = pd.DataFrame.from_records(data, index='timestamp', columns=columns)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Columns: ['timestamp', 'latitude', 'longitude', 'altitude', 'capture_id', 'dls-yaw', 'dls-pitch', 'dls-roll', 'irr-475', 'irr-560', 'irr-668', 'irr-842', 'irr-717'] ++
+
+
+
+
+
+
+
+
+Mapping capture locations using MapboxGL¶
Below we use the mapboxgl extension to plot the measured DLS yaw (or heading) angle from each image's meatadata over the whole imageset. We draw circles at each image location, and then color the circle based on the yaw value.
+
+
+
+
+
+
+
+
+In [13]:
+
+
+
+
+
+
+import math
+import numpy as np
+from mapboxgl.viz import *
+from mapboxgl.utils import df_to_geojson, create_radius_stops, scale_between
+from mapboxgl.utils import create_color_stops
+
+#Insert your mapbox token here
+token = 'pk.eyJ1IjoibWljYXNlbnNlIiwiYSI6ImNqYWx5dWNteTJ3cWYzMnBicmZid3g2YzcifQ.Zrq9t7GYocBtBzYyT3P4sw'
+color_stops = create_color_stops(np.linspace(-math.pi,math.pi,num=8),colors='YlOrRd')
+data = df_to_geojson(df,columns[3:],lat='latitude',lon='longitude')
+viz = CircleViz(data, access_token=token, color_property='dls-yaw',
+ color_stops=color_stops,
+ center=[df['longitude'].median(),df['latitude'].median()],
+ zoom=16, height='600px',
+ style='mapbox://styles/mapbox/satellite-streets-v9')
+viz.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/Users/stephen/anaconda3/envs/micasense/lib/python3.7/site-packages/IPython/core/display.py:724: UserWarning: Consider using IPython.display.IFrame instead
+ warnings.warn("Consider using IPython.display.IFrame instead")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Plotting capture metadata¶
+
+
+
+
+
+
+
+
+
+In [14]:
+
+
+
+
+
+
+import matplotlib.pyplot as plt
+%matplotlib inline
+ax=df.plot(y=columns[3:], subplots=True, figsize=(16, 10), style=['g','c','y','k','b','g','r','m','k']);
+for a in ax:
+ a.legend(loc='right', bbox_to_anchor=(1.1, 0.5), ncol=1, fancybox=True, shadow=True);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Separating ground and flight images¶
We can plot a histogram of the image altitudes for all images in the flight and use the basic statistics to guess at an altitude below which the panel images were likely taken. This can give us an altitude threshold we can apply to separate images taken in flight and on the ground.
+ +
+
+
+
+
+
+
+
+
+In [15]:
+
+
+
+
+
+
+# plot the histogram of the altitude data
+df.altitude.hist();
+# find the altitude above which the flight images occur
+cutoff_altitude = df.altitude.mean()-3.0*df.altitude.std()
+plt.axvline(x=cutoff_altitude,c='r');
+plt.xlabel('Capture altitude (m)');
+plt.ylabel('Number of occurances');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Automatically extracting radiances of panel images¶
Using the Panel class, we can automatically find and compute the radiance of panel regions within panel images. Each Capture object exposes a panel_radiance() method which can be used on panel images to get a list of the radiance of each band (in the native RedEdge band order).
+
+
+
+
+
+
+
+
+In [ ]:
+
+
+
+
+
+
+import numpy as np
+flight = df.altitude>cutoff_altitude
+ground = ~flight
+ground_idx = np.arange(len(ground))[ground]
+flight_idx = np.arange(len(ground))[flight]
+ground_captures = np.array(imgset.captures)[ground_idx]
+flight_captures = np.array(imgset.captures)[flight_idx]
+
+panel_radiances = []
+dls_irradiances = []
+panel_timestamps = []
+for cap in ground_captures:
+ if cap.panels_in_all_expected_images():
+ panel_timestamps.append(cap.utc_time())
+ panel_radiances.append(cap.panel_radiance())
+ dls_irradiances.append(cap.dls_irradiance())
+
+dls_irradiances = np.asarray(dls_irradiances)
+panel_radiances = np.asarray(panel_radiances)
+
+###
+panel_reflectance_by_band = [0.49, 0.49, 0.49, 0.49, 0.49] #RedEdge band_index order
+panel_irradiance = ground_captures[0].panel_irradiance(panel_reflectance_by_band)
+plt.figure()
+plt.scatter(ground_captures[0].center_wavelengths(), panel_irradiance);
+plt.xscale('log')
+plt.ylabel("Irradiance (w/m^2/nm)");
+plt.xlabel("Wavelength (nm)");
+
+
+
+
+
+
+
+
+
+Plotting DLS Irradiances¶
Once we have extracted the panel radiances from the ground images, we can convert them to irradiance as we did in tutorial #1 and plot the irradiances over time and extract radiance to reflectance conversion factors.
+ +
+
+
+
+
+
+
+
+
+In [18]:
+
+
+
+
+
+
+import matplotlib.pyplot as plt
+import math
+
+df[df.altitude>cutoff_altitude].plot(y=columns[8:13], figsize=(14,8))
+plt.ylabel("Irradiance (w/m^2/nm)");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Images.html b/docs/Images.html
new file mode 100644
index 00000000..01c51198
--- /dev/null
+++ b/docs/Images.html
@@ -0,0 +1,14746 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2018 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+Images¶
This notebook shows usage for the Image type. This type is useful for loading single image files, reading the embedded metadata, and performing radiometric calibrations.
+ +
+
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+from micasense.image import Image
+import os, glob
+%matplotlib inline
+
+imagePath = os.path.join('.','data','ALTUM')
+imageName = glob.glob(os.path.join(imagePath,'IMG_0021_1.tif'))[0]
+
+img = Image(imageName)
+img.plot_all();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Image Histogram¶
+
+
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+
+nbins = 1024
+vmin = 0
+vmax = 2**16
+bins = range(vmin,vmax, int(vmax/nbins))
+hist = cv2.calcHist([img.raw().ravel()],[0],None,[nbins],[vmin,vmax])
+plt.plot(bins,hist);
+plt.xlim(img.raw().min(),img.raw().max())
+plt.ylim(0,hist.max())
+plt.xlabel('Pixel Value')
+plt.ylabel('Frequency')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/MicaSense Image Processing Setup.html b/docs/MicaSense Image Processing Setup.html
new file mode 100644
index 00000000..b4c47a70
--- /dev/null
+++ b/docs/MicaSense Image Processing Setup.html
@@ -0,0 +1,14901 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+MicaSense Image Processing Setup¶
Overview¶
This series of tutorials will be a walk through on how to process RedEdge data from raw images through conversion to reflectance. In this first tutorial, we will cover the tools required to do this, get them installed, and verify that the installation works.
+System Requirements¶
Our tutorials are written using Python3. Python has great library support for image processing through libraries such as OpenCV, SciKit Image, and others. In this tutorial, we'll use python, OpenCV, numpy, and matplotlib, as well as the standalone exiftool and it's python wrapper to open and manipulate RedEdge images to transform raw digital number values into quantitative reflectance.
+This tutorial has been tested on Windows, MacOS, and Linux. It is likely to work on other platforms, especially unix-based platforms like OSX, but you will have to do the legwork to get the required software installed and working.
+Software/Libraries Overview¶
The following softare and libraries are required for this tutorial:
+-
+
- python3 +
- numpy +
- openCV +
- matplotlib +
- exiftool + pyexiftool (version 0.4.13 only) +
- scikit-image +
- zbar + pyzbar +
- pysolar +
- pandas +
- mapboxgl +
Below, we go through the options to download and install a full working python environment with these tools (and their dependencies). We're using the Anaconda or miniconda environments where possible to ease installation, but if you're already a python package management guru, you can use git to checkout this code repository and look at the micasense_conda_env.yml file for the dependencies you'll need in your virtual environment.
Linux (Debian/Ubuntu)¶
For linux (and Mac, to some extent) you can either install the libraries directly using pip or install miniconda or anaconda to create completely separate environments. We have had success installing miniconda locally -- it's a smaller install than anaconda and can be installed without using sudo and doesn't impact the system-installed python or python libraries. You will likely still need to use sudo to install
The following is what we had to do on a fresh Ubuntu 18.04 image to install the library. First we installed some system tools and libraries:
+ +sudo apt install git
+sudo apt install libzbar0
+sudo apt install make
+
+Next we installed exiftool:
+ +wget https://exiftool.org/Image-ExifTool-12.57.tar.gz
+tar -xvzf Image-ExifTool-12.57.tar.gz
+cd Image-ExifTool-12.57/
+perl Makefile.PL
+make test
+sudo make install
+
+Then we installed miniconda. Navigate to the miniconda download page and download the installer for your system and follow the installation instructions
+Once these tools are installed, you can check out this repository and create the micasense conda environment:
git clone https://github.com/micasense/imageprocessing.git
+cd imageprocessing
+conda env create -f micasense_conda_env.yml
+
+Finally, one way to verify our install by running the built in tests:
+ +cd imageprocessing
+conda activate micasense
+pytest .
+
+Or, to start working with the notebooks (including running the test code below):
+ +cd imageprocessing
+conda activate micasense
+jupyter notebook .
+
+
+Windows setup¶
When installing on Windows we rely on the Anaconda python environment to do most of the heavy lifting for us.
+-
+
Install Anaconda for your system by downloading the Python 3.7 version
+-
+
- When installing Anaconda, choose "install for only me" instead of "install for all users," as this simplifies installation of other packages +
+Download the exiftool windows package and unzip it to a permanent location such as
+c:\exiftool\. Now we need to tell the python code where to find exiftool (so we don't have to set it up in every script we write), and we do that by adding the path to exiftool as an environment variable.-
+
- Create an environment variable called
exiftoolpathwith a value of the full path to exiftool. For example,c:\exiftool\exiftool.exe
+ - To do this on Windows 10, press Start button or the Windows key, then type
Pathand clickEdit Environment Variables for Your Account
+ - Click
New
+ - In Variable Name type
exiftoolpath
+ - In Variable Value type
c:\exiftool\exiftool.exe
+
+- Create an environment variable called
Open an Anaconda console from the start menu as an administrator by clicking
+Start->Anaconda, right-clickAnaconda Console, chooseRun as Administrator. Execute the following commands in the anaconda console:-
+
cdto the directory you git cloned this repository to
+conda env create -f micasense_conda_env.yml
+- This will configure an anaconda environment with all of the required tools and libraries This will take a while depending on your computer and internet speeds (5-10 minutes is not uncommon) +
- When it's done, run
activate micasenseto activate the environment configured
+ - Each time you run start a new anaconda prompt, you'll need to run
activate micasense
+
+
MacOS setup¶
The following steps to get going on MacOS worked for us.
+First we installed git by installing the xcode developer tools, or you can follow the instructions at the git site.
Next, we downloaded and installed exiftool using the MacOS installer.
+Third, we installed Homebrew and used it to install zbar:
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+brew install zbar
+
+Then we installed miniconda. If you're comfortable on the command line, navigate to the miniconda download page and download the installer for your system. Open an iTerm and follow the installation instructions.
+If instead you're more comfortable with graphical installers, the Anaconda version for Python 3.7 may be right for you.
+Once these tools are installed, you can check out this repository and create the micasense conda environment by opening an iTerm and running the following commands:
git clone https://github.com/micasense/imageprocessing.git
+cd imageprocessing
+conda env create -f micasense_conda_env.yml
+
+This will take a while (5-10 minutes isn't uncommon). Once it's done, one way to verify our install by running the built-in tests:
+ +conda activate micasense
+pytest .
+
+Or, to start working with the notebooks (including running the test code below):
+ +cd imageprocessing
+conda activate micasense
+jupyter notebook .
+
+
+Running the notebooks¶
-
+
- If running on Windows, run the
Anaconda Promptfrom the Start menu and typeactivate micasense
+ cdto the imageprocessing checkout directory
+- Run
jupyter notebook .
+
Testing Installation¶
The following python snippet can be run from a jupyter notebook, inside iPython, or by saving to a script and running from the command line. If you're on windows, make sure you have set the location of exiftool in the exiftoolpath environment variable. If this script succeeds, your system is ready to go! If not, check the installation documentation for the module import that is having issues.
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+import cv2 #openCV
+import exiftool
+import os, glob
+import numpy as np
+import pyzbar.pyzbar as pyzbar
+import matplotlib.pyplot as plt
+import mapboxgl
+
+print()
+print("Successfully imported all required libraries.")
+print()
+
+if os.name == 'nt':
+ if os.environ.get('exiftoolpath') is None:
+ print("Set the `exiftoolpath` environment variable as described above")
+ else:
+ if not os.path.isfile(os.environ.get('exiftoolpath')):
+ print("The provided exiftoolpath isn't a file, check the settings")
+
+try:
+ with exiftool.ExifTool(os.environ.get('exiftoolpath')) as exift:
+ print('Successfully executed exiftool.')
+except Exception as e:
+ print("Exiftool isn't working. Double check that you've followed the instructions above.")
+ print("The execption text below may help to find the source of the problem:")
+ print()
+ print(e)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++Successfully imported all required libraries. + +Successfully executed exiftool. ++
+
+
+
+
+
+
+
+
+Testing image reading and panel detection¶
The above code checks for the proper libraries to be installed and verifies it can execute exiftool. This code opens an example image, reads the metadata, and then uses the pyzbar library to find a MicaSense panel in the image.
+
+
+
+
+
+
+
+
+In [5]:
+
+
+
+
+
+
+from micasense.image import Image
+imagePath = os.path.join('.','data','REDEDGE-MX')
+imageName = glob.glob(os.path.join(imagePath,'IMG_0001_1.tif'))[0]
+
+img = Image(imageName)
+img.plot_raw(figsize=(8.73,8.73));
+
+from micasense.panel import Panel
+panel = Panel(img)
+if not panel.panel_detected():
+ raise IOError("Panel Not Detected! Check your installation of pyzbar")
+else:
+ panel.plot(figsize=(8,8));
+
+print('Success! Now you are ready for Part 1 of the tutorial.')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Success! Now you are ready for Part 1 of the tutorial. ++
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/MicaSense Image Processing Tutorial 1.html b/docs/MicaSense Image Processing Tutorial 1.html
new file mode 100644
index 00000000..eec2cd4c
--- /dev/null
+++ b/docs/MicaSense Image Processing Tutorial 1.html
@@ -0,0 +1,15372 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+MicaSense RedEdge Image Processing Tutorial 1¶
Overview¶
This tutorial assumes you have gone through the basic setup here and your system is set up and ready to go.
+In this tutorial, we will walk through how to convert RedEdge data from raw images to radiace and then to reflectance. We will cover the tools required to do this, and walk through some of the basic image processing and radiometric conversions.
+Opening an image with pyplot¶
RedEdge 16-bit images can be read with pyplot directly into numpy arrays using the pyplot imread function or the matplotlib imread function, and then we can display the image inline using the imshow function of matplotlib.
+
+
+
+
+
+
+
+
+In [9]:
+
+
+
+
+
+
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+import os,glob
+import math
+%matplotlib inline
+
+imagePath = os.path.join('.','data','REDEDGE-MX')
+imageName = os.path.join(imagePath,'IMG_0001_4.tif')
+
+# Read raw image DN values
+# reads 16 bit tif - converts 12 bit to 16 bit if necessary
+imageRaw=plt.imread(imageName)
+
+# Display the image
+fig, ax = plt.subplots(figsize=(8,6))
+ax.imshow(imageRaw, cmap='gray')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+MicaSense Utilities Module¶
For many of the steps in the tutorial, we will use code from the MicaSense utilities module. The code is in the micasense directory and can be imported via normal python import commands using the syntax import micasense or import micasense.submodule as short_name for use in this and other scripts. While we will not cover all of the utility functions in this tutorial, they are available for reference and some will be used and discussed in future tutorials.
Adding a colorbar¶
We will use start by using a plotting function in micasense.plotutils that adds a colorbar to the display, so that we can more easily see changes in the values in the images and also see the range of the image values after various conversions. This function also colorizes the grayscale images, so that changes can more easily be seen. Depending on your viewing style, you may prefer a different color map and you can also select that colormap here or browsing the colormaps on the matplotlib site.
+
+
+
+
+
+
+
+
+In [10]:
+
+
+
+
+
+
+import micasense.plotutils as plotutils
+
+# Optional: pick a color map that fits your viewing style
+# one of 'gray, viridis, plasma, inferno, magma, nipy_spectral'
+plotutils.colormap('viridis');
+
+fig = plotutils.plotwithcolorbar(imageRaw, title='Raw image values with colorbar')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<Figure size 432x288 with 0 Axes>+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Reading RedEdge Metadata¶
In order to perform various processing on the images, we need to read the metadata of each image. For this we use ExifTool. We can read standard image capture metadata such as location, UTC time, imager exposure and gain, but also RedEdge specific metadata which can make processing workflows easier.
+For example, each image contains a unique capture identifier. Capture identifiers are shared between all 5 images captured by RedEdge at the same moment, and can be used to unambiguously group images in post processing, regardless of how the images are named or stored on disk. Each image also contains a flight identifer which is the same for all images taken during a single power cycle of the camera. This can be used in post-processing workflows to group images and in many cases, more easily identify when the vehicle took off and landed.
+ +
+
+
+
+
+
+
+
+
+In [11]:
+
+
+
+
+
+
+import micasense.metadata as metadata
+exiftoolPath = None
+if os.name == 'nt':
+ exiftoolPath = os.environ.get('exiftoolpath')
+# get image metadata
+meta = metadata.Metadata(imageName, exiftoolPath=exiftoolPath)
+cameraMake = meta.get_item('EXIF:Make')
+cameraModel = meta.get_item('EXIF:Model')
+firmwareVersion = meta.get_item('EXIF:Software')
+bandName = meta.get_item('XMP:BandName')
+print('{0} {1} firmware version: {2}'.format(cameraMake,
+ cameraModel,
+ firmwareVersion))
+print('Exposure Time: {0} seconds'.format(meta.get_item('EXIF:ExposureTime')))
+print('Imager Gain: {0}'.format(meta.get_item('EXIF:ISOSpeed')/100.0))
+print('Size: {0}x{1} pixels'.format(meta.get_item('EXIF:ImageWidth'),meta.get_item('EXIF:ImageHeight')))
+print('Band Name: {0}'.format(bandName))
+print('Center Wavelength: {0} nm'.format(meta.get_item('XMP:CentralWavelength')))
+print('Bandwidth: {0} nm'.format(meta.get_item('XMP:WavelengthFWHM')))
+print('Capture ID: {0}'.format(meta.get_item('XMP:CaptureId')))
+print('Flight ID: {0}'.format(meta.get_item('XMP:FlightId')))
+print('Focal Length: {0}'.format(meta.get_item('XMP:FocalLength')))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+MicaSense RedEdge-M firmware version: v7.5.0-beta6 +Exposure Time: 0.00036 seconds +Imager Gain: 1.0 +Size: 1280x960 pixels +Band Name: NIR +Center Wavelength: 842 nm +Bandwidth: 57 nm +Capture ID: Rb0pibHa08uHJwrTjf8Y +Flight ID: ePdxBBmSitgkTdpwZiM9 +Focal Length: None ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Converting raw images to Radiance¶
Ultimately most RedEdge users want to calibrate raw images from the camera into reflectance maps. This can be done using off-the-shelf software from third parties, but you are here because there is no fun in that! Along with this tutorial we have included some helper utilities that will handle much of this conversion for you, but here we will walk through a few of those functions to discuss what is happening inside.
+Any RedEdge workflow must include these common steps.
+-
+
- Un-bias images by accounting for the dark pixel offset +
- Compensate for imager-level effects +
- Compensate for optical chain effects +
- Normalize images by exposure and gain settings +
- Convert to a common unit system (radiance) +
All of these are handled by the micasense.utils.raw_image_to_radiance(metadata, raw_image) function. Let us take a look at that fuction in more detail.
First, we get the darkPixel values. These values come from optically-covered pixels on the imager which are exposed at the same time as the image pixels. They measure the small amount of random charge generation in each pixel, independent of incoming light, which is common to all semiconductor imaging devices.
+blackLevel = np.array(meta.get_item('Exif.BlackLevel'))
+ darkLevel = blackLevel.mean()
+Now, we get the imager-specific calibrations.
+a1, a2, a3 = meta.get_item('XMP:RadiometricCalibration')
+We get the parameters of the optical chain (vignette) effects and create a vignette map. This map will be multiplied by the black-level corrected image values to reverse the darkening seen at the image corners. See the vignette_map function for the details of the vignette parameters and their use.
V, x, y = vignette_map(meta, xDim, yDim)
+Now we can calculate the imager-specfic radiometric correction function, which help to account for the radiometric inaccuracies of the CMOS imager pixels.
+# row gradient correction
+ R = 1.0 / (1.0 + a2 * y / exposureTime - a3 * y)
+Finally, we apply these functions to the raw image to result in a corrected image
+# subtract the dark level and adjust for vignette and row gradient
+ L = V * R * (imageRaw - darkLevel)
+Next, we get the exposure and gain settings (gain is represented in the photographic parameter ISO, with a base ISO of 100, so we divide the result to get a numeric gain).
+exposureTime = float(meta.get_item('EXIF:ExposureTime'))
+ gain = float(meta.get_item('EXIF:ISOSpeed'))/100.0
+Now that we have a corrected image, we can apply a conversion from calibrated digital number values to radiance units (W/m^2/nm/sr). Note that in this conversion, we need to normalize by the image bitdepth (2^16 for 16 bit images, 2^12 for 12-bit images), because the calibration coefficients are scaled to work with normalized input values.
+# apply the radiometric calibration -
+ # scale by the gain-exposure product and multiply with the radiometric calibration coefficient
+ bitsPerPixel = meta.get_item('EXIF:BitsPerSample')
+ dnMax = float(2**bitsPerPixel)
+ radianceImage = L.astype(float)/(gain * exposureTime)*a1/dnMax
+For convenience, we have written the raw_image_to_radiance function to return the intermediate compensation images as well, so we can visualize them for the tutorial. These intermediate results are not required in most implementations and can be ommitted, if performance is a concern.
+
+
+
+
+
+
+
+
+In [12]:
+
+
+
+
+
+
+import micasense.utils as msutils
+radianceImage, L, V, R = msutils.raw_image_to_radiance(meta, imageRaw)
+plotutils.plotwithcolorbar(V,'Vignette Factor');
+plotutils.plotwithcolorbar(R,'Row Gradient Factor');
+plotutils.plotwithcolorbar(V*R,'Combined Corrections');
+plotutils.plotwithcolorbar(L,'Vignette and row gradient corrected raw values');
+plotutils.plotwithcolorbar(radianceImage,'All factors applied and scaled to radiance');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Convert radiance to reflectance¶
Now that we have a flat and calibrated radiance image, we can convert into reflectance. To do this, we will use the radiance values of the panel image of known reflectance to determine a scale factor between radiance and reflectance.
+In this case, we have our MicaSense calibrated reflectance panel and its known reflectance of 49% in the band of interest. We will extract the area of the image containing the lambertian panel, determine it's radiance to reflectance scale factor, and then scale the whole image by that factor to get a reflectance image.
+ +
+
+
+
+
+
+
+
+
+In [13]:
+
+
+
+
+
+
+markedImg = radianceImage.copy()
+ulx = 610 # upper left column (x coordinate) of panel area
+uly = 610 # upper left row (y coordinate) of panel area
+lrx = 770 # lower right column (x coordinate) of panel area
+lry = 760 # lower right row (y coordinate) of panel area
+cv2.rectangle(markedImg,(ulx,uly),(lrx,lry),(0,255,0),3)
+
+# Our panel calibration by band (from MicaSense for our specific panel)
+panelCalibration = {
+ "Blue": 0.49,
+ "Green": 0.49,
+ "Red": 0.49,
+ "Red edge": 0.49,
+ "NIR": 0.49
+}
+
+# Select panel region from radiance image
+panelRegion = radianceImage[uly:lry, ulx:lrx]
+plotutils.plotwithcolorbar(markedImg, 'Panel region in radiance image')
+meanRadiance = panelRegion.mean()
+print('Mean Radiance in panel region: {:1.3f} W/m^2/nm/sr'.format(meanRadiance))
+panelReflectance = panelCalibration[bandName]
+radianceToReflectance = panelReflectance / meanRadiance
+print('Radiance to reflectance conversion factor: {:1.3f}'.format(radianceToReflectance))
+
+reflectanceImage = radianceImage * radianceToReflectance
+plotutils.plotwithcolorbar(reflectanceImage, 'Converted Reflectane Image');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Mean Radiance in panel region: 0.105 W/m^2/nm/sr +Radiance to reflectance conversion factor: 4.649 ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+In some cases we might notice that some parts of a converted reflectance image show reflectances above 1.0, or 100%, and wonder how this is possible. In fact, reflectances higher than 100% are normal in specific cases of specular reflections. The panel area is a special material that reflects incident light equally well in all directions; however, some of the objects in a scene (especially man-made objects) instead reflect most incident light in one direction, more like a mirror. An example is the reflection of the sun off of the smooth surface of a car or the reflection off of a body of water.
+Now we will extract the same region and verify the reflectance in that region is what we expect. In the process, we will blur and visualize the extracted area to look for any trends. The area should have a very consistent reflectance. If a gradient or a high standard deviation (>3% absolute reflectance) is noticed across the panel area it is possible that the panel was captured under inconsistent lighting conditions (e.g. next to a wall or vehicle) or it was captured too close to the edge of the image where the optical calibration is the least accurate.
+ +
+
+
+
+
+
+
+
+
+In [14]:
+
+
+
+
+
+
+panelRegionRaw = imageRaw[uly:lry, ulx:lrx]
+panelRegionRefl = reflectanceImage[uly:lry, ulx:lrx]
+panelRegionReflBlur = cv2.GaussianBlur(panelRegionRefl,(55,55),5)
+plotutils.plotwithcolorbar(panelRegionReflBlur, 'Smoothed panel region in reflectance image')
+print('Min Reflectance in panel region: {:1.2f}'.format(panelRegionRefl.min()))
+print('Max Reflectance in panel region: {:1.2f}'.format(panelRegionRefl.max()))
+print('Mean Reflectance in panel region: {:1.2f}'.format(panelRegionRefl.mean()))
+print('Standard deviation in region: {:1.4f}'.format(panelRegionRefl.std()))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Min Reflectance in panel region: 0.43 +Max Reflectance in panel region: 0.59 +Mean Reflectance in panel region: 0.49 +Standard deviation in region: 0.0152 ++
+
+
+
+
+
+
+
+
+In this case the panel is less uniform than we would like, but we can also notice that the full color scale is only 4% of absolute reflectance. Likewise, it's well below the standard deviation threshold we have set of 3% absolute reflectance. This panel has seen over two years of hard field use, so it may be time for it to retire.
+Reasons for a high standard deviation across a panel can include panel contamination or inconsistent lighting across the panel due to environmental conditions. Based on the context of the image, it is also clear that the user is taking the panel image facing the sun, which can cast reflected light from the operator's clothing on the panel and contaminate results. For this reason it is always best to capture panel images in an open area and with the operator's back to the sun.
+Undistorting images¶
Finally, we need to remove lens distortion effects from images for some processing workflows, such as band-to-band image alignment. Generally for photogrammetry processes on raw (or radiance/reflectance) images, this step is not required, as the photogrammetry process will optimize a lens distortion model as part of it's bulk bundle adjustment. RedEdge has very low distortion lenses, so the changes to images in this step tend to be very small and noticeable only in pixels on the border of the image.
+ +
+
+
+
+
+
+
+
+
+In [15]:
+
+
+
+
+
+
+# correct for lens distortions to make straight lines straight
+undistortedReflectance = msutils.correct_lens_distortion(meta, reflectanceImage)
+plotutils.plotwithcolorbar(undistortedReflectance, 'Undistorted reflectance image');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+In Practice¶
Now that we can convert from raw RedEge images to reflectance, we will use these methods to convert an image taken during the same campaign to a reflectance image, and look at a few interesting areas of the image to validate our conversion.
+ +
+
+
+
+
+
+
+
+
+In [16]:
+
+
+
+
+
+
+flightImageName = os.path.join(imagePath,'IMG_0001_4.tif')
+flightImageRaw=plt.imread(flightImageName)
+plotutils.plotwithcolorbar(flightImageRaw, 'Raw Image')
+
+flightRadianceImage, _, _, _ = msutils.raw_image_to_radiance(meta, flightImageRaw)
+flightReflectanceImage = flightRadianceImage * radianceToReflectance
+flightUndistortedReflectance = msutils.correct_lens_distortion(meta, flightReflectanceImage)
+plotutils.plotwithcolorbar(flightUndistortedReflectance, 'Reflectance converted and undistorted image');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Conclusion¶
In this tutorial we have found that we can read MicaSense RedEdge images and their metadata, and use python and OpenCV to convert those images to radiance and then to reflectance using the standard scientific field method of imaging a lambertian reflector. We have corrected for both the electro-optical effects of the sensor and optical chain, as well as the incident light at the time of capture.
+In future tutorials, we will introduce the Downwelling Light Sensor (DLS) information into the calibration process in order to account for changing irradiance over time (e.g. such as clouds). However, since the panel method is straightforward and repeatable under constant illumination conditions, and is the standard scientific calibration method of surface reflectance, this process is useful and sufficient for many calibration needs.
+Looking for more? Try the second tutorial here.
+ +
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/MicaSense Image Processing Tutorial 2.html b/docs/MicaSense Image Processing Tutorial 2.html
new file mode 100644
index 00000000..697a6cad
--- /dev/null
+++ b/docs/MicaSense Image Processing Tutorial 2.html
@@ -0,0 +1,15115 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+
+Tutorial 2 - MicaSense library¶
This tutorial assumes you have gone through the basic setup and builds on the basic radiance, irradiance, and reflectance concepts and code covered in the first tutorial.
+In this tutorial, we will cover usage of the MicaSense python library to access images and groups of images. Most of the processing details are hidden away in the library, but the library code is open and available in the git repository.
+Library Components¶
In the first tutorial, we introduced micasense.utils which provided some helper functions for single image manipulation, and micasense.plotutils which provided some plotting helpers.
For this second tutorial, we are going to introduce the usage of the included micasense libraries for opening, converting, and displaying images. This will allow us to discuss and visualize results at a high level, while the underlying source code is available for those interested in the implementation details. In some cases, the libraries themselves may be enough to implement a custom workflow without the need to re-implement or translate the code to another system or language.
+The library code provides some basic classes to manage image data. At the highest level is the ImageSet, which is able to load a list of files or recursively search a whole directory into data structures which are easy to access and manipulate. ImageSets are made up of Captures, which hold the set of (usually 5) images as they are simultaneously gathered by the RedEdge camera. Within Captures are Images, which hold a single image file and allow easy access to the image metadata. The Image class also provides the ability to extract metadata from individual images and to convert individual images in similar ways to those described in the first tutorial.
For the rest of this article, we will look at each of the objects available starting with the single Image object, and work our way up to the whole ImageSet. Each section in this article is standalone, and can be copied into another workbook or edited in place to explore more of the functions associated with that object.
+
+
+
+
+
+
+
+
+micasense.Image¶
An image is the lowest level object. It represents the data in a single tiff file as taken by the camera. Image objects expose a set of data retrieval methods which provide access to raw, radiance, and reflectance corrected images, and to undistort any of those images. Note that when retrieving image data from an Image object, the data is stored internally in the object, increasing the object's memory footprint. If operating on a large number of images, it may be necessary to release this data memory after each image is processed to limit the program memory footprint. This can be done by calling the Image.clear_image_data() method.
+
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+import os
+import micasense.image as image
+%matplotlib inline
+
+image_path = os.path.join('.','data','ALTUM','IMG_0000_1.tif')
+img = image.Image(image_path)
+img.plot_raw();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Accessing
+Accessing Image Metadata¶
Metadata for each image is available in the Image.meta parameter. This object is a micasense.Metadata object and can be accessed directly for image specific metadata extraction. Below, we print the same metadata values as we did in Tutorial #1, but using direct access to the Metadata object parameters.
A notebook for experimenting with the Image class can be found here.
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+print('{0} {1} firmware version: {2}'.format(img.meta.camera_make(),
+ img.meta.camera_model(),
+ img.meta.firmware_version()))
+print('Exposure Time: {0} seconds'.format(img.meta.exposure()))
+print('Imager Gain: {0}'.format(img.meta.gain()))
+print('Size: {0}x{1} pixels'.format(img.meta.image_size()[0],
+ img.meta.image_size()[1]))
+print('Band Name: {0}'.format(img.meta.band_name()))
+print('Center Wavelength: {0} nm'.format(img.meta.center_wavelength()))
+print('Bandwidth: {0} nm'.format(img.meta.bandwidth()))
+print('Capture ID: {0}'.format(img.meta.capture_id()))
+print('Flight ID: {0}'.format(img.meta.flight_id()))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+MicaSense Altum firmware version: v2.5.0-beta6 +Exposure Time: 0.000423757 seconds +Imager Gain: 1.0 +Size: 2064x1544 pixels +Band Name: Blue +Center Wavelength: 475 nm +Bandwidth: 20 nm +Capture ID: CoDN4adNch7KFnclyi5t +Flight ID: jfCG6qSK0t7CDUvnJiOO ++
+
+
+
+
+
+
+
+
+micasense.Capture¶
The Capture class is a container for Images which allows access to metadata common to the group of images. The internal Image objects are accessible via the capture.images properties, and images in this list are kept sorted by the band property. Data which is different for each image can be accessed through composite methods, such as the capture.dls_irradiance() method, which returns a list of irradiances in band order.
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+import os, glob
+import micasense.capture as capture
+
+images_path = os.path.join('.','data','ALTUM')
+image_names = glob.glob(os.path.join(images_path,'IMG_0000_*.tif'))
+cap = capture.Capture.from_filelist(image_names)
+cap.plot_radiance();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Acessing
+Acessing Capture metadata¶
Metadata which is common to all captures can be accessed via methods on the Capture object. Metadata which varies between the images of the capture, such as DLS information, is available as lists accessed from the capture object.
+ Note: The lists returned from metadata access on the `Capture` object are returned in `band_index` order. All images within a capture are sorted by the image `band_index`, and all lists adhere to this ordering. This ordering is consistent with the number at the end of each filename of a RedEdge image.
+
Below we plot the raw and tilt compensated DLS irradiance by center wavelength and by band name.
+ +
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+import matplotlib.pyplot as plt
+
+print(cap.band_names())
+fig = plt.figure(figsize=(14,6))
+plt.subplot(1,2,1)
+plt.scatter(cap.center_wavelengths(), cap.dls_irradiance())
+plt.ylabel('Irradiance $(W/m^2/nm)$')
+plt.xlabel('Center Wavelength (nm)')
+plt.subplot(1,2,2)
+plt.scatter(cap.band_names(), [img.meta.exposure() for img in cap.images])
+plt.xlabel('Band Names')
+plt.ylim([0,2.5e-3])
+plt.ylabel('Exposure Time (s)')
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+['Blue', 'Green', 'Red', 'NIR', 'Red edge', 'LWIR'] ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+A notebook for experimenting with the Capture class can be found here.
+
+
+
+
+
+
+
+
+micasense.Panel¶
The Panel class is a helper class which can automatically extract panel information from MicaSense calibrated reflectance panels by finding the QR code within an image and using the QR Code location and orientation information to find the lambertian panel area. The class then allows extraction of statistics from the panel area such as mean raw values, mean radiance, standard deviation, and the number of saturated pixels in the panel region. The panel object can be included standalone, or used within the context of a Capture object.
+ Note: For the automatic panel QR code finding functions of the library to work, zbar and it's python bindings must be installed. We have made every effort to ensure this fails gracefully if zbar isn't available. Unfortunately zbar is only available using Python 2.7, not Python 3. If you're using Python 3.x, the code available in '/micasense/panel.py' shows how to find QR codes in images and to find the panel area from the QR location. We're currently looking for Python QR code finding options that work across platforms and Python versions, let us know if you have one that supports location!
+
+
+
+
+
+
+
+
+
+
+In [5]:
+
+
+
+
+
+
+import os, glob
+import micasense.image as image
+import micasense.panel as panel
+
+image_path = os.path.join('.','data','ALTUM','IMG_0000_1.tif')
+img = image.Image(image_path)
+
+pnl = panel.Panel(img)
+print("Panel found: {}".format(pnl.panel_detected()))
+print("Panel serial: {}".format(pnl.serial))
+print("QR Code Corners:\n{}".format(pnl.qr_corners()))
+mean, std, count, saturated_count = pnl.raw()
+print("Panel mean raw pixel value: {}".format(mean))
+print("Panel raw pixel standard deviation: {}".format(std))
+print("Panel region pixel count: {}".format(count))
+print("Panel region saturated pixel count: {}".format(count))
+
+pnl.plot();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Panel found: True +Panel serial: RP06-2051037-OB +QR Code Corners: +None +Panel mean raw pixel value: 32852.294381134314 +Panel raw pixel standard deviation: 396.866996832778 +Panel region pixel count: 15181 +Panel region saturated pixel count: 15181 ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+A notebook for experimenting with the Panel class can be found here
+
+
+
+
+
+
+
+
+micasense.ImageSet¶
An ImageSet contains a group of Captures. The captures can be loaded from image object, from a list of files, or by recursively searching a directory for images.
Loading an ImageSet can be a time consuming process. It uses python multithreading under the hood to maximize cpu usage on multi-core machines.
+
+
+
+
+
+
+
+
+In [6]:
+
+
+
+
+
+
+from ipywidgets import FloatProgress
+from IPython.display import display
+f = FloatProgress(min=0, max=1)
+display(f)
+def update_f(val):
+ f.value=val
+
+import micasense.imageset as imageset
+import os
+images_dir = os.path.join('.','data','ALTUM')
+
+imgset = imageset.ImageSet.from_directory(images_dir, progress_callback=update_f)
+
+for cap in imgset.captures:
+ print ("Opened Capture {} with bands {}".format(cap.uuid,[str(band) for band in cap.band_names()]))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FloatProgress(value=0.0, max=1.0)+
+
+
+
+
+
+
+
+
+
+Opened Capture CoDN4adNch7KFnclyi5t with bands ['Blue', 'Green', 'Red', 'NIR', 'Red edge', 'LWIR'] +Opened Capture E9PO6BRS2ua7AnqabMMH with bands ['Blue', 'Green', 'Red', 'NIR', 'Red edge', 'LWIR'] ++
+
+
+
+
+
+
+
+
+
+Extended ImageSet examples¶
A large group of images captured over a central California orchard are available for download here.
+With this set extracted to a working folder, the extended ImageSet example notebook provides more usages of ImageSet data.
+Conclusion¶
In this tutorial, we have introduced the MicaSense library and provided some examples of opening Images, Captures, and ImageSets, as well as detecting and extracting panel information from images.
+The next tutorial covers basic usage of DLS information, and is available here
+ +
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/MicaSense Image Processing Tutorial 3.html b/docs/MicaSense Image Processing Tutorial 3.html
new file mode 100644
index 00000000..7020afc1
--- /dev/null
+++ b/docs/MicaSense Image Processing Tutorial 3.html
@@ -0,0 +1,14927 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+
+Tutorial 3 - DLS Sensor Basic Usage¶
This tutorial will walk through how to convert RedEdge data from raw images to radiace and then use the DLS information in the image metadata to convert that to reflectance.
+ +
+
+
+
+
+
+
+
+
+
+Update for DLS2¶
This tutorial was originally written as a guide to basic processing of DLS1 data for RedEdge-3 and RedeEdge-M. Since October 2018, Altum and RedEdge-MX have been shipped standard with DLS2. DLS1 is a small, red square with a single diffuser on top. DLS2 is a larger, thinner black rectangle with two small diffusers on top and 8 small diffusers on different up-looking faces.
+For DLS2 data, we recommend using the Capture class to access the Capture.dls_irradiance() method. This will provide a compensated horizontal irradiance useful for radiometrically correcting imagery. We leave the below intact for legacy users and as a tutorial on remote sensing calibrations and terms.
For RedEdge and Altum with up-to-date firmware, the EXIF:HorizontalIrradiance tag and the appropriate scale factor will provide the necessary information for reflectance compensation. If necessary, this can be further field-calibrated by using a pane image to tie the DLS2 and camera calibrations together in-situ.
+
+
+
+
+
+
+
+
+
+Remote Sensing Theory¶
In Tutorial 1 we covered conversion of the image radiance to reflecance using the average radiance from an area of a specially made lambertian reflectance panel. As we did not get very far into remote sensing theory, we will cover that some here as we move on to the more complex problem of using the data from the RedEdge Downwelling Light Sensor (DLS). To get started, we will review some of the fundamental measurements in remote sensing.
+Definition of Terms¶
The DLS measures the energy coming from the sky, while the camera measures the energy coming from the fields below. The property that we are generally looking to estimate in agricultural remote sensing is the surface reflectance of the plants and ground below the sensor.
+The MicaSense RedEdge measures spectral radiance, a measure of the power incident on the CMOS image sensor at each pixel, and has units power per unit area per unit bandwidth per unit solid angle (W/m^2/nm/sr). We will call the radiance image L.
+The MicaSense Downwelling Light Sensor (DLS) measures incoming spectral irradiance on the top surface of the device for the same 5 spectral bands as the camera. Irradiance has the units of power per unit area per unit bandwidth, or Watts per meter squared per nanometer (W/m^2/nm). We will call this downwelling quantity I.
+If we look closely at the units, they differ by the last term - the unit over solid angle. This is because each pixel of the camera sensor only sees a specific solid angle, while the dls detector has a specific area.
+Understanding the measurements¶
In order to use downwelling irradiance and upwelling radiance to determine reflectance, we simply need to divide pi times the irradiance by the radiance. Our units cancel out, and we are left with the unitless quantity of reflectance. However, there is one caveat. In most systems, the DLS is not held level to the ground at all times, so the amount of light that shines on it's surface changes as the aircraft moves about. In oder for that simple math to work, it's necessary that the irradiance and radiance be compensated for a very important property: the illumination angle.
+Both the radiance and irradiance are sensitive to changes in the direction of the lighting. Both quantites decrease with the cosine of the angle from the surface normal, eventually reaching zero when the light source is parallel to the surface. So when measuring irradiance, this effect needs to be corrected in order to estimate the actual irradiance.
+Different types of irradiance¶
To complicate matters further, the light reaching the DLS and the ground is not coming from a single source, even under sunny conditions. The direct sunlight provides what we will call the direct source, resulting in a direct irradiance I_direct. The rest of the (usually blue) sky provides what we term the indirect, or diffuse, irradiance which we will call I_diffuse. Under even the sunniest conditions with the summer sun directly overhead, only about 85% of the light is direct, while the other 15% is diffuse, which we will express as the ratio 6:1. Under thin cloud conditions, this ratio drops to close 1:1, meaning half of the measured irradiance is coming from parts of the sky other than the direction of the sun. The ratio goes even lower under fully cloudy skies, becoming fully diffuse.
As we ultimately want to estimate the time-varying irradiance, we will need to estimate both the direct and diffuse irradiance terms as well as correct for the cosine effect of the DLS sensor itself.
+Sensor-specific challenges¶
There's one final piece of theory required that pertains to irradiance sensing, and that is the Fresnel Effect. The Fresnel Effect describes a physical property of the diffuser that gathers light on top of the DLS. This effect results from the fact that much of the light striking the diffuser is reflected, and the amount reflected changes with the angle of the incident light. So, instead of our diffuser behaving as a perfect cosine detector, we need to also compensate for the material imperfections.
+DLS pose estimation¶
An onboard orientation sensor provides a fairly rough version of the earth-fixed orientation of the DLS. The quality of this orientation varies based on the quality of the sensor installation and calibration, but in even the best cases it has a few degrees of error. If the DLS and the camera are mounted fixed to one another, the photogrammetric workflow can be used to augment the orientation of the irradiance sensor. Our examples here will use the sensor measurements directly, but significant improvements can be made using the very precise angles photorammetry can provide.
+Radiometric calibration options¶
As we've discussed in the first tutorial, the method of using a calibrated reflectance panel is the scientific standard for remote sensing measurements. Spectroradiometers which cost tens of thousands of dollars are calibrated in this method in the field. Panels images may also be used both before and after each flight to track slowly changing solar irradiance. In many cases of direct sunlight with no clouds, panel images can provide the best results when taken before and after each flight. As the diffuse lighting increases, the utility of the DLS increases as well.
+In cases of more varied irradiance, the DLS can be used for irradiance estimation, using only the internal pose estimation. The DLS irradiance can be be used in conjunction with panels to ensure that the DLS and panel measurements match at the time of panel capture. In order for this to be effective, it's important that the DLS and panel are exposed to the same irradiance. This is best accomplished by ensuring panel images are taken with the operator's back to the sun and the operator shadow next to the panel. The aircraft and operator should block as little of the sky as possible.
+Finally, in fixed mount systems, the photogrammetric angles can be used, along with the offset between the camera and DLS sensors, to most accurately estimate irradiance. This can again be coupled with one or more panel measurements for best radiometric results.
+ +
+
+
+
+
+
+
+
+
+Putting it all Together¶
Below, we will use the micasense.Capture class to load a set of images and use tilt-compensated DLS irradiance data to roughly translate those images to reflectance. We will then compare these to the known reflectances of a lambertian panel, and develop a site-specific compensation factor to tie together the DLS irradiance and camera radiance measurements through the panel.
Accessing and processing DLS data¶
Below, we show how to access DLS data and compute the minimum required corrections to the DLS data for use. The code in this cell is present in the micasense.dls library, and is used by the Image and Capture class to expose corrected DLS data. If your intent is to simply use this code to correct your data, you can skip this section and access pose-corrected DLS data through the capture.dls_irradiance() method.
For the purpose of this tutorial, we assume a constant irradiance (over time) and a ratio of direct to diffuse irradiance of 6:1. These assumptions only hold approximately, and only for clear sky. Cloud cover can lead to dramatically different results.
+Loading Captures¶
+
+
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+import numpy as np
+import micasense.dls as dls
+
+import os, glob
+import micasense.capture as capture
+
+images_path = os.path.join('.','data','REDEDGE-P')
+image_names = glob.glob(os.path.join(images_path,'IMG_0000_*.tif'))
+cap = capture.Capture.from_filelist(image_names)
+
+
+
+
+
+
+
+
+
+Computing Solar orientation¶
+
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+# Define DLS sensor orientation vector relative to dls pose frame
+dls_orientation_vector = np.array([0,0,-1])
+# compute sun orientation and sun-sensor angles
+(
+ sun_vector_ned, # Solar vector in North-East-Down coordinates
+ sensor_vector_ned, # DLS vector in North-East-Down coordinates
+ sun_sensor_angle, # Angle between DLS vector and sun vector
+ solar_elevation, # Elevation of the sun above the horizon
+ solar_azimuth, # Azimuth (heading) of the sun
+) = dls.compute_sun_angle(cap.location(),
+ cap.dls_pose(),
+ cap.utc_time(),
+ dls_orientation_vector)
+
+
+
+
+
+
+
+
+
+Correcting DLS readings for orientations¶
+
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+# Since the diffuser reflects more light at shallow angles than at steep angles,
+# we compute a correction for this
+fresnel_correction = dls.fresnel(sun_sensor_angle)
+
+# Now we can correct the raw DLS readings and compute the irradiance on level ground
+dls_irradiances = []
+center_wavelengths = []
+for img in cap.images:
+ dir_dif_ratio = 6.0
+ percent_diffuse = 1.0/dir_dif_ratio
+ # measured Irradiance / fresnelCorrection
+ sensor_irradiance = img.spectral_irradiance / fresnel_correction
+ untilted_direct_irr = sensor_irradiance / (percent_diffuse + np.cos(sun_sensor_angle))
+ # compute irradiance on the ground using the solar altitude angle
+ dls_irr = untilted_direct_irr * (percent_diffuse + np.sin(solar_elevation))
+ dls_irradiances.append(dls_irr)
+ center_wavelengths.append(img.center_wavelength)
+
+import matplotlib.pyplot as plt
+plt.scatter(center_wavelengths,dls_irradiances)
+plt.xlabel('Wavelength (nm)')
+plt.ylabel('Irradiance ($W/m^2/nm$)')
+plt.show();
+
+cap.plot_undistorted_reflectance(dls_irradiances)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Tying the camera and DLS together via Panels¶
Finally, if we want to use the panel as the ultimate reference tying the panel and the DLS readings together with a known lambertian reflector, we can calculate a DLS factor which we can then apply to DLS derived irradiances over the whole flight.
+ +
+
+
+
+
+
+
+
+
+In [4]:
+
+
+
+
+
+
+import math
+
+panel_reflectance_by_band = [0.49] * len(cap.eo_band_names()) # This panel has an average of 49% reflectance for each EO band
+
+panel_radiances = np.array(cap.panel_radiance())
+irr_from_panel = math.pi * panel_radiances / panel_reflectance_by_band
+dls_correction = irr_from_panel/dls_irradiances
+cap.plot_undistorted_reflectance(dls_irradiances*dls_correction)
+
+plt.scatter(cap.center_wavelengths(), cap.panel_reflectance())
+plt.title("Panel Reflectances")
+plt.xlabel("Wavelength (nm)")
+plt.ylabel("Reflectance")
+plt.show()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Future improvements¶
While the need to compensate the DLS for movement increases the complexity of the problem, it also provides us more information than might be available for other diffuser types. This is because as the DLS moves about on the aircraft, it provides many measurements per second that should all have consistent effects assuming the light isn't changing over those very fast measurements. This movement can then be used to develop an irradiance series which uses all of the available information from the on board sensors. A future tutorial will provide an overview of some methods for improving irradiance sensing further.
+ +
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/Panels.html b/docs/Panels.html
new file mode 100644
index 00000000..df8e8dca
--- /dev/null
+++ b/docs/Panels.html
@@ -0,0 +1,14797 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2019 MicaSense, Inc. For licensing information see the project git repository
+ +
+
+
+
+
+
+
+
+
+Panels¶
This notebook shows usage for the Panel class. This type is useful for detecting MicaSense calibration panels and extracting information about the lambertian panel surface.
+ +
+
+
+
+
+
+
+
+In [1]:
+
+
+
+
+
+
+%load_ext autoreload
+%autoreload 2
+
+
+
+
+
+
+
+
+In [2]:
+
+
+
+
+
+
+import os, glob
+from micasense.image import Image
+from micasense.panel import Panel
+%matplotlib inline
+
+imagePath = os.path.join('.','data','ALTUM')
+imageName = glob.glob(os.path.join(imagePath,'IMG_0000_4.tif'))[0]
+
+img = Image(imageName)
+panel = Panel(img)
+
+if not panel.panel_detected():
+ raise IOError("Panel Not Detected!")
+
+print("Detected panel serial: {}".format(panel.serial))
+mean, std, num, sat_count = panel.raw()
+print("Extracted Panel Statistics:")
+print("Mean: {}".format(mean))
+print("Standard Deviation: {}".format(std))
+print("Panel Pixel Count: {}".format(num))
+print("Saturated Pixel Count: {}".format(sat_count))
+
+panel.plot();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Detected panel serial: RP06-2051037-OB +Extracted Panel Statistics: +Mean: 31758.02988274707 +Standard Deviation: 386.3622284454486 +Panel Pixel Count: 14925 +Saturated Pixel Count: 0 ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+In [3]:
+
+
+
+
+
+
+# imagePath = os.path.join('.','data','ALTUM1SET','000')
+# imageName = glob.glob(os.path.join(imagePath,'IMG_0000_1.tif'))[0]
+
+imagePath = os.path.join('.','data','ALTUM')
+imageName = glob.glob(os.path.join(imagePath,'IMG_0000_4.tif'))[0]
+
+img = Image(imageName)
+if img.auto_calibration_image:
+ print("Found automatic calibration image")
+panel = Panel(img)
+
+if not panel.panel_detected():
+ raise IOError("Panel Not Detected!")
+
+print("Detected panel serial: {}".format(panel.serial))
+mean, std, num, sat_count = panel.raw()
+print("Extracted Panel Statistics:")
+print("Mean: {}".format(mean))
+print("Standard Deviation: {}".format(std))
+print("Panel Pixel Count: {}".format(num))
+print("Saturated Pixel Count: {}".format(sat_count))
+
+panel.plot();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Found automatic calibration image +Detected panel serial: RP06-2051037-OB +Extracted Panel Statistics: +Mean: 31758.02988274707 +Standard Deviation: 386.3622284454486 +Panel Pixel Count: 14925 +Saturated Pixel Count: 0 ++
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/index.ipynb b/index.ipynb
index c1ed80ce..75fbf6b5 100644
--- a/index.ipynb
+++ b/index.ipynb
@@ -6,7 +6,7 @@
"source": [
"# MicaSense Image Processing Tutorials \n",
"\n",
- "This repository includes tutorials and examples for processing MicaSense RedEdge and MicaSense Altum images into usable information using the python programming language. The intended audience is researchers and engineers with some software development experience that want to do their own image processing. While a number of commercial tools fully support processing RedEdge data into reflectance maps, there are a number of reasons to process your own data, including controlling the entire radiometric workflow (for academic or publication reasons), pre-processing images to be used in a non-radiometric photogrammetry suite, or processing single sets of 5 images without building a larger map.\n",
+ "This repository includes tutorials and examples for processing MicaSense RedEdge-M/MX, Altum, RedEdge-P, and Altum-PT images into usable information using the Python programming language. The intended audience is researchers and engineers with some software development experience that want to do their own image processing. While a number of commercial tools fully support processing MicaSense data into reflectance maps, there are a number of reasons to process your own data. This can include: controlling the entire radiometric workflow (for academic or publication reasons), pre-processing images to be used in a non-radiometric photogrammetry suite, or processing single sets of images (captures) without building a larger map.\n",
"\n",
"To get started, browse the examples below, and then head over to the [git repository](https://github.com/micasense/imageprocessing) to check out the code.\n",
"\n",
@@ -35,6 +35,8 @@
"* [Capture Alignment and Analysis Examples](Alignment.html)\n",
"* [Capture Alignment Using Rig Relatives](Alignment-RigRelatives.html)\n",
"* [Batch processing into stacked TIFFs](Batch%20Processing.html)\n",
+ "* [Capture Alignment and Analysis Examples (Updated 2023 for Panchromatic cameras)](Alignment%20v2.html)\n",
+ "* [Batch processing into stacked TIFFs (2023 version)](Batch%20Processing%20v2.html)\n",
"\n",
"### 10-Band (Dual Camera) Examples\n",
"* [10-band Capture Alignment](Alignment-10Band.html)\n",
@@ -52,7 +54,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3",
+ "display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
@@ -66,7 +68,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.7.3"
+ "version": "3.7.12"
}
},
"nbformat": 4,
diff --git a/micasense/capture.py b/micasense/capture.py
index f831daf9..e5eeea94 100644
--- a/micasense/capture.py
+++ b/micasense/capture.py
@@ -1,12 +1,12 @@
#!/usr/bin/env python
# coding: utf-8
"""
-RedEdge Capture Class
+MicaSense Capture Class
- A Capture is a set of images taken by one RedEdge cameras which share
- the same unique capture identifier. Generally these images will be
+ A Capture is a set of Images taken by one camera which share
+ the same unique capture identifier (capture_id). Generally these images will be
found in the same folder and also share the same filename prefix, such
- as IMG_0000_*.tif, but this is not required
+ as IMG_0000_*.tif, but this is not required.
Copyright 2017 MicaSense, Inc.
@@ -27,91 +27,162 @@
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-import micasense.image as image
-import micasense.dls as dls
-import micasense.plotutils as plotutils
-import micasense.imageutils as imageutils
+import logging
import math
-import numpy as np
-import cv2
import os
+from collections import namedtuple
+
+import cv2
import imageio
+import numpy as np
+from skimage.feature import match_descriptors, SIFT
+from skimage.measure import ransac
+from skimage.transform import estimate_transform, FundamentalMatrixTransform, ProjectiveTransform, \
+ resize
+
+import micasense.image as image
+import micasense.imageutils as imageutils
+import micasense.plotutils as plotutils
+
class Capture(object):
"""
- A capture is a set of images taken by one RedEdge cameras which share
- the same unique capture identifier. Generally these images will be
+ A Capture is a set of Images taken by one MicaSense camera which share
+ the same unique capture identifier (capture_id). Generally these images will be
found in the same folder and also share the same filename prefix, such
- as IMG_0000_*.tif, but this is not required
+ as IMG_0000_*.tif, but this is not required.
"""
- def __init__(self, images, panelCorners=None):
+
+ def __init__(self, images, panel_corners=None):
+ """
+ :param images: str or List of str system file paths.
+ Class is typically created using from_file() or from_file_list() methods.
+ Captures are also created automatically using ImageSet.from_directory()
+ :param panel_corners: 3d List of int coordinates
+ e.g. [[[873, 1089], [767, 1083], [763, 1187], [869, 1193]],
+ [[993, 1105], [885, 1101], [881, 1205], [989, 1209]],
+ [[1000, 1030], [892, 1026], [888, 1130], [996, 1134]],
+ [[892, 989], [786, 983], [780, 1087], [886, 1093]],
+ [[948, 1061], [842, 1057], [836, 1161], [942, 1165]]]
+
+ The camera should automatically detect panel corners. This instance variable will be None for aerial
+ captures. You can populate this for panel captures by calling detect_panels().
+ """
if isinstance(images, image.Image):
self.images = [images]
elif isinstance(images, list):
self.images = images
else:
- raise RuntimeError("Provide an image or list of images to create a Capture")
+ raise RuntimeError("Provide an Image or list of Images to create a Capture.")
self.num_bands = len(self.images)
self.images.sort()
capture_ids = [img.capture_id for img in self.images]
if len(set(capture_ids)) != 1:
- raise RuntimeError("Images provided are required to all have the same capture id")
+ raise RuntimeError("Images provided must have the same capture_id.")
self.uuid = self.images[0].capture_id
+ self.flightid = self.images[0].flight_id
+ self.camera_model = self.images[0].camera_model
+ self.camera_serial = self.images[0].camera_serial
+ self.camera_serials = set([img.camera_serial for img in self.images])
+ self.bits_per_pixel = self.images[0].bits_per_pixel
self.panels = None
self.detected_panel_count = 0
- if panelCorners is None:
- self.panelCorners = [None]*len(self.eo_indices())
+ if panel_corners is None:
+ self.panelCorners = [None] * len(self.eo_indices())
else:
- self.panelCorners = panelCorners
+ self.panelCorners = panel_corners
self.__aligned_capture = None
-
- def set_panelCorners(self,panelCorners):
- self.panelCorners = panelCorners
+ self.__aligned_radiometric_pan_sharpened_capture = None
+ self.__sift_warp_matrices = None
+
+ def set_panel_corners(self, panel_corners):
+ """
+ Define panel corners by hand.
+ :param panel_corners: 2d List of int coordinates.
+ e.g. [[536, 667], [535, 750], [441, 755], [444, 672]]
+ :return: None
+ """
+ self.panel_corners = panel_corners
self.panels = None
self.detect_panels()
- def append_image(self, image):
- if self.uuid != image.capture_id:
- raise RuntimeError("Added images must have the same capture id")
- self.images.append(image)
+ def append_image(self, img):
+ """
+ Add an Image to the Capture.
+ :param img: An Image object.
+ :return: None
+ """
+ if self.uuid != img.capture_id:
+ raise RuntimeError("Added images must have the same capture_id.")
+ self.images.append(img)
self.images.sort()
def append_images(self, images):
+ """
+ Add multiple Images to the Capture.
+ :param images: List of Image objects.
+ """
[self.append_image(img) for img in images]
def append_file(self, file_name):
+ """
+ Add an Image to the Capture using a file path.
+ :param file_name: str system file path.
+ """
self.append_image(image.Image(file_name))
@classmethod
- def from_file(cls, file_name):
- return cls(image.Image(file_name))
+ def from_file(cls, file_name, allow_uncalibrated=False):
+ """
+ Create Capture instance from file path.
+ :param file_name: str system file path
+ :return: Capture object.
+ """
+ return cls(image.Image(file_name, allow_uncalibrated=allow_uncalibrated))
@classmethod
- def from_filelist(cls, file_list):
+ def from_filelist(cls, file_list, allow_uncalibrated=False):
+ """
+ Create Capture instance from List of file paths.
+ :param file_list: List of str system file paths.
+ :return: Capture object.
+ """
if len(file_list) == 0:
- raise IOError("No files provided. Check your file paths")
+ raise IOError("No files provided. Check your file paths.")
for fle in file_list:
if not os.path.isfile(fle):
- raise IOError("All files in file list must be a file. The following file is not:\nfle")
- images = [image.Image(fle) for fle in file_list]
+ raise IOError(f"All files in file list must be a file. The following file is not:\n{fle}")
+ images = [image.Image(fle, allow_uncalibrated=allow_uncalibrated) for fle in file_list]
return cls(images)
def __get_reference_index(self):
- # find the reference image which has the smallest rig offsets - they should be (0,0)
- return np.argmin((np.array([i.rig_xy_offset_in_px() for i in self.images])**2).sum(1))
+ """
+ Find the reference image which has the smallest rig offsets - they should be (0,0).
+ :return: ndarray of ints - The indices of the minimum values along an axis.
+ """
+ return np.argmin((np.array([i.rig_xy_offset_in_px() for i in self.images]) ** 2).sum(1))
def __plot(self, imgs, num_cols=2, plot_type=None, colorbar=True, figsize=(14, 14)):
- ''' plot the radiance images for the capture '''
- if plot_type == None:
+ """
+ Plot the Images from the Capture.
+ :param images: List of Image objects
+ :param num_cols: int number of columns
+ :param plot_type: str for plot title formatting
+ :param color_bar: boolean to determine color bar inclusion
+ :param fig_size: Tuple size of the figure
+ :return: plotutils result. matplotlib Figure and Axis in both cases.
+ """
+ if plot_type is None:
plot_type = ''
else:
titles = [
- '{} Band {} {}'.format(str(img.band_name), str(img.band_index), plot_type if img.band_name.upper() != 'LWIR' else 'Brightness Temperature')
+ '{} Band {} {}'.format(str(img.band_name), str(img.band_index),
+ plot_type if img.band_name.upper() != 'LWIR' else 'Brightness Temperature')
for img
in self.images
]
- num_rows = int(math.ceil(float(len(self.images))/float(num_cols)))
+ num_rows = int(math.ceil(float(len(self.images)) / float(num_cols)))
if colorbar:
return plotutils.subplotwithcolorbar(num_rows, num_cols, imgs, titles, figsize)
else:
@@ -127,138 +198,188 @@ def __eq__(self, other):
return self.uuid == other.uuid
def location(self):
- ''' (lat, lon, alt) tuple of WGS-84 location units are radians, meters msl'''
- return (self.images[0].location)
+ """(lat, lon, alt) tuple of WGS-84 location units are radians, meters msl"""
+ return self.images[0].location
def utc_time(self):
- ''' returns a timezone-aware datetime object of the capture time '''
+ """Returns a timezone-aware datetime object of the capture time."""
return self.images[0].utc_time
def clear_image_data(self):
- '''Clears (dereferences to allow garbage collection) all internal image
- data stored in this class. Call this after processing-heavy image
- calls to manage program memory footprint. When processing many images,
- such as iterating over the captures in an ImageSet, it may be necessary
- to call this after capture is processed'''
+ """
+ Clears (dereferences to allow garbage collection) all internal image data stored in this class. Call this
+ after processing-heavy image calls to manage program memory footprint. When processing many images, such as
+ iterating over the Captures in an ImageSet, it may be necessary to call this after Capture is processed.
+ """
for img in self.images:
img.clear_image_data()
self.__aligned_capture = None
+ self.__aligned_radiometric_pan_sharpened_capture = None
def center_wavelengths(self):
- '''Returns a list of the image center wavelenghts in nanometers'''
+ """Returns a list of the image center wavelengths in nanometers."""
return [img.center_wavelength for img in self.images]
def band_names(self):
- '''Returns a list of the image band names as they are in the image metadata'''
+ """Returns a list of the image band names as they are in the image metadata."""
return [img.band_name for img in self.images]
-
+
def band_names_lower(self):
- '''Returns a list of the image band names in all lower case for easier comparisons'''
+ """Returns a list of the Image band names in all lower case for easier comparisons."""
return [img.band_name.lower() for img in self.images]
def dls_present(self):
- '''Returns true if DLS metadata is present in the images'''
+ """Returns true if DLS metadata is present in the images."""
return self.images[0].dls_present
def dls_irradiance_raw(self):
- '''Returns a list of the raw DLS measurements from the image metadata'''
+ """Returns a list of the raw DLS measurements from the image metadata."""
return [img.spectral_irradiance for img in self.images]
def dls_irradiance(self):
- '''Returns a list of the corrected earth-surface (horizontal) DLS irradiance in W/m^2/nm'''
+ """Returns a list of the corrected earth-surface (horizontal) DLS irradiance in W/m^2/nm."""
return [img.horizontal_irradiance for img in self.images]
def direct_irradiance(self):
- '''Returns a list of the DLS irradiance from the direct source in W/m^2/nm'''
+ """Returns a list of the DLS irradiance from the direct source in W/m^2/nm."""
return [img.direct_irradiance for img in self.images]
+
def scattered_irradiance(self):
- '''Returns a list of the DLS irradiance from the direct source in W/m^2/nm'''
+ """Returns a list of the DLS scattered irradiance from the direct source in W/m^2/nm."""
return [img.scattered_irradiance for img in self.images]
def dls_pose(self):
- '''Returns (yaw,pitch,roll) tuples in radians of the earth-fixed dls pose'''
- return (self.images[0].dls_yaw, self.images[0].dls_pitch, self.images[0].dls_roll)
+ """Returns (yaw, pitch, roll) tuples in radians of the earth-fixed DLS pose."""
+ return self.images[0].dls_yaw, self.images[0].dls_pitch, self.images[0].dls_roll
+
+ def focal_length(self):
+ """Returns focal length of multispectral bands or of panchromatic band if applicable."""
+ if 'Panchro' in self.eo_band_names():
+ return self.images[self.eo_band_names().index('Panchro')].focal_length
+ else:
+ return self.images[0].focal_length
def plot_raw(self):
- '''Plot raw images as the data came from the camera'''
+ """Plot raw images as the data came from the camera."""
self.__plot([img.raw() for img in self.images],
plot_type='Raw')
def plot_vignette(self):
- '''Compute (if necessary) and plot vignette correction images'''
+ """Compute (if necessary) and plot vignette correction images."""
self.__plot([img.vignette()[0].T for img in self.images],
plot_type='Vignette')
def plot_radiance(self):
- '''Compute (if necessary) and plot radiance images'''
+ """Compute (if necessary) and plot radiance images."""
self.__plot([img.radiance() for img in self.images],
plot_type='Radiance')
def plot_undistorted_radiance(self):
- '''Compute (if necessary) and plot undistorted radiance images'''
+ """Compute (if necessary) and plot undistorted radiance images."""
self.__plot(
- [img.undistorted(img.radiance()) for img in self.images],
- plot_type='Undistored Radiance')
+ [img.undistorted(img.radiance()) for img in self.images],
+ plot_type='Undistorted Radiance')
def plot_undistorted_reflectance(self, irradiance_list):
- '''Compute (if necessary) and plot reflectances given a list of irrdiances'''
+ """
+ Compute (if necessary) and plot reflectances given a list of irradiances.
+ :param irradiance_list: List returned from Capture.dls_irradiance() or Capture.panel_irradiance()
+ """
self.__plot(
- self.undistorted_reflectance(irradiance_list),
- plot_type='Undistorted Reflectance')
+ self.undistorted_reflectance(irradiance_list),
+ plot_type='Undistorted Reflectance')
def compute_radiance(self):
+ """
+ Compute Image radiances.
+ :return: None
+ """
[img.radiance() for img in self.images]
def compute_undistorted_radiance(self):
+ """
+ Compute Image undistorted radiance.
+ :return: None
+ """
[img.undistorted_radiance() for img in self.images]
def compute_reflectance(self, irradiance_list=None, force_recompute=True):
- '''Compute image reflectance from irradiance list, but don't return'''
+ """
+ Compute Image reflectance from irradiance list, but don't return.
+ :param irradiance_list: List returned from Capture.dls_irradiance() or Capture.panel_irradiance()
+ :param force_recompute: boolean to determine if reflectance is recomputed.
+ :return: None
+ """
if irradiance_list is not None:
- [img.reflectance(irradiance_list[i], force_recompute=force_recompute) for i,img in enumerate(self.images)]
+ [img.reflectance(irradiance_list[i], force_recompute=force_recompute) for i, img in enumerate(self.images)]
else:
[img.reflectance(force_recompute=force_recompute) for img in self.images]
def compute_undistorted_reflectance(self, irradiance_list=None, force_recompute=True):
- '''Compute image reflectance from irradiance list, but don't return'''
+ """
+ Compute undistorted image reflectance from irradiance list.
+ :param irradiance_list: List returned from Capture.dls_irradiance() or Capture.panel_irradiance() TODO: improve this docstring
+ :param force_recompute: boolean to determine if reflectance is recomputed.
+ :return: None
+ """
if irradiance_list is not None:
- [img.undistorted_reflectance(irradiance_list[i], force_recompute=force_recompute) for i,img in enumerate(self.images)]
+ [img.undistorted_reflectance(irradiance_list[i], force_recompute=force_recompute) for i, img in
+ enumerate(self.images)]
else:
[img.undistorted_reflectance(force_recompute=force_recompute) for img in self.images]
-
def eo_images(self):
+ """Returns a list of the EO Images in the Capture."""
return [img for img in self.images if img.band_name != 'LWIR']
def lw_images(self):
+ """Returns a list of the longwave infrared Images in the Capture."""
return [img for img in self.images if img.band_name == 'LWIR']
def eo_indices(self):
- return [index for index,img in enumerate(self.images) if img.band_name != 'LWIR']
+ """Returns a list of the indexes of the EO Images in the Capture."""
+ return [index for index, img in enumerate(self.images) if img.band_name != 'LWIR']
+
+ def eo_band_names(self):
+ return [band for band in self.band_names() if band != 'LWIR']
def lw_indices(self):
- return [index for index,img in enumerate(self.images) if img.band_name == 'LWIR']
+ """Returns a list of the indexes of the longwave infrared Images in the Capture."""
+ return [index for index, img in enumerate(self.images) if img.band_name == 'LWIR']
def reflectance(self, irradiance_list):
- '''Comptute and return list of reflectance images for given irradiance'''
- eo_imgs = [img.reflectance(irradiance_list[i]) for i,img in enumerate(self.eo_images())]
- lw_imgs = [img.reflectance() for i,img in enumerate(self.lw_images())]
+ """
+ Compute reflectance Images.
+ :param irradiance_list: List returned from Capture.dls_irradiance() or Capture.panel_irradiance() TODO: improve this docstring
+ :return: List of reflectance EO and long wave infrared Images for given irradiance.
+ """
+ eo_imgs = [img.reflectance(irradiance_list[i]) for i, img in enumerate(self.eo_images())]
+ lw_imgs = [img.reflectance() for i, img in enumerate(self.lw_images())]
return eo_imgs + lw_imgs
def undistorted_reflectance(self, irradiance_list):
- '''Comptute and return list of reflectance images for given irradiance'''
- eo_imgs = [img.undistorted(img.reflectance(irradiance_list[i])) for i,img in enumerate(self.eo_images())]
- lw_imgs = [img.undistorted(img.reflectance()) for i,img in enumerate(self.lw_images())]
+ """
+ Compute undistorted reflectance Images.
+ :param irradiance_list: List returned from Capture.dls_irradiance() or Capture.panel_irradiance() TODO: improve this docstring
+ :return: List of undistorted reflectance images for given irradiance.
+ """
+ eo_imgs = [img.undistorted(img.reflectance(irradiance_list[i])) for i, img in enumerate(self.eo_images())]
+ lw_imgs = [img.undistorted(img.reflectance()) for i, img in enumerate(self.lw_images())]
return eo_imgs + lw_imgs
def panels_in_all_expected_images(self):
+ """
+ Check if all expected reflectance panels are detected in the EO Images in the Capture.
+ :return: True if reflectance panels are detected.
+ """
expected_panels = sum(str(img.band_name).upper() != 'LWIR' for img in self.images)
return self.detect_panels() == expected_panels
def panel_raw(self):
+ """Return a list of mean panel region values for raw images."""
if self.panels is None:
if not self.panels_in_all_expected_images():
- raise IOError("Panels not detected in all images")
+ raise IOError("Panels not detected in all images.")
raw_list = []
for p in self.panels:
mean, _, _, _ = p.raw()
@@ -266,9 +387,10 @@ def panel_raw(self):
return raw_list
def panel_radiance(self):
+ """Return a list of mean panel region values for converted radiance Images."""
if self.panels is None:
if not self.panels_in_all_expected_images():
- raise IOError("Panels not detected in all images")
+ raise IOError("Panels not detected in all images.")
radiance_list = []
for p in self.panels:
mean, _, _, _ = p.radiance()
@@ -276,31 +398,34 @@ def panel_radiance(self):
return radiance_list
def panel_irradiance(self, reflectances=None):
+ """Return a list of mean panel region values for irradiance values."""
if self.panels is None:
if not self.panels_in_all_expected_images():
- raise IOError("Panels not detected in all images")
- if reflectances == None:
+ raise IOError("Panels not detected in all images.")
+ if reflectances is None:
reflectances = [panel.reflectance_from_panel_serial() for panel in self.panels]
if len(reflectances) != len(self.panels):
- raise ValueError("Length of panel reflectances must match lengh of images")
+ raise ValueError("Length of panel reflectances must match length of Images.")
irradiance_list = []
- for i,p in enumerate(self.panels):
+ for i, p in enumerate(self.panels):
mean_irr = p.irradiance_mean(reflectances[i])
irradiance_list.append(mean_irr)
return irradiance_list
- def panel_reflectance(self, panel_refl_by_band=None):
+ def panel_reflectance(self):
+ """Return a list of mean panel reflectance values."""
if self.panels is None:
if not self.panels_in_all_expected_images():
- raise IOError("Panels not detected in all images")
+ raise IOError("Panels not detected in all images.")
reflectance_list = []
- for i,p in enumerate(self.panels):
+ for i, p in enumerate(self.panels):
self.images[i].reflectance()
mean_refl = p.reflectance_mean()
reflectance_list.append(mean_refl)
return reflectance_list
def panel_albedo(self):
+ """Return a list of panel reflectance values from metadata."""
if self.panels_in_all_expected_images():
albedos = [panel.reflectance_from_panel_serial() for panel in self.panels]
if None in albedos:
@@ -310,180 +435,503 @@ def panel_albedo(self):
return albedos
def detect_panels(self):
+ """Detect reflectance panels in the Capture, and return a count."""
from micasense.panel import Panel
if self.panels is not None and self.detected_panel_count == len(self.images):
return self.detected_panel_count
- self.panels = [Panel(img,panelCorners=pc) for img,pc in zip(self.images,self.panelCorners)]
+ self.panels = [Panel(img, panel_corners=pc) for img, pc in zip(self.images, self.panelCorners)]
self.detected_panel_count = 0
for p in self.panels:
if p.panel_detected():
self.detected_panel_count += 1
# is panelCorners are defined by hand
if self.panelCorners is not None and all(corner is not None for corner in self.panelCorners):
- self.detected_panel_count = len(self.panelCorners)
+ self.detected_panel_count = len(self.panelCorners)
return self.detected_panel_count
def plot_panels(self):
+ """Plot Panel images."""
if self.panels is None:
if not self.panels_in_all_expected_images():
- raise IOError("Panels not detected in all images")
+ raise IOError("Panels not detected in all images.")
self.__plot(
[p.plot_image() for p in self.panels],
plot_type='Panels',
colorbar=False
)
- def set_external_rig_relatives(self,external_rig_relatives):
- for i,img in enumerate(self.images):
+ def set_external_rig_relatives(self, external_rig_relatives):
+ """
+ Set external rig relatives.
+ :param external_rig_relatives: TODO: Write this parameter docstring
+ :return: None
+ """
+ for i, img in enumerate(self.images):
img.set_external_rig_relatives(external_rig_relatives[str(i)])
def has_rig_relatives(self):
+ """
+ Check if Images in Capture have rig relatives.
+ :return: boolean True if all Images have rig relatives metadata.
+ """
for img in self.images:
if img.meta.rig_relatives() is None:
return False
return True
def get_warp_matrices(self, ref_index=None):
+ """
+ Get warp matrices.
+ :param ref_index: int to specify image for homography
+ :return: 2d List of warp matrices
+ """
if ref_index is None:
ref = self.images[self.__get_reference_index()]
else:
ref = self.images[ref_index]
- warp_matrices =[np.linalg.inv(im.get_homography(ref)) for im in self.images]
- return [w/w[2,2] for w in warp_matrices]
-
- def create_aligned_capture(self, irradiance_list=None, warp_matrices=None, normalize=False, img_type=None, motion_type=cv2.MOTION_HOMOGRAPHY):
+ warp_matrices = [np.linalg.inv(im.get_homography(ref)) for im in self.images]
+ return [w / w[2, 2] for w in warp_matrices]
+
+ def create_aligned_capture(self, irradiance_list=None, warp_matrices=None, img_type=None,
+ motion_type=cv2.MOTION_HOMOGRAPHY):
+ """
+ Creates aligned Capture. Computes undistorted radiance or reflectance images if necessary.
+ :param irradiance_list: List of mean panel region irradiance.
+ :param warp_matrices: 2d List of warp matrices derived from Capture.get_warp_matrices()
+ :param normalize: FIXME: This parameter isn't used?
+ :param img_type: str 'radiance' or 'reflectance' depending on image metadata.
+ :param motion_type: OpenCV import. Also know as warp_mode. MOTION_HOMOGRAPHY or MOTION_AFFINE.
+ For Altum images only use HOMOGRAPHY.
+ :return: ndarray with alignment changes
+ """
if img_type is None and irradiance_list is None and self.dls_irradiance() is None:
self.compute_undistorted_radiance()
img_type = 'radiance'
elif img_type is None:
if irradiance_list is None:
- irradiance_list = self.dls_irradiance()+[0]
+ irradiance_list = self.dls_irradiance() + [0]
self.compute_undistorted_reflectance(irradiance_list)
img_type = 'reflectance'
if warp_matrices is None:
warp_matrices = self.get_warp_matrices()
- cropped_dimensions,_ = imageutils.find_crop_bounds(self,warp_matrices,warp_mode=motion_type)
+ if self.camera_model in ('RedEdge-P', 'Altum-PT'):
+ match_index = 5
+ reference_band = 5
+ logging.warning(
+ "For RedEdge-P or Altum-PT, you should use SIFT_align_capture instead of create_aligned_capture")
+ # for RedEdge-MX Dual Camera System
+ elif len(self.eo_band_names()) == 10:
+ match_index = 4
+ reference_band = 0
+ else:
+ match_index = 1
+ reference_band = 0
+ cropped_dimensions, _ = imageutils.find_crop_bounds(self, warp_matrices, warp_mode=motion_type,
+ reference_band=reference_band)
self.__aligned_capture = imageutils.aligned_capture(self,
- warp_matrices,
- motion_type,
- cropped_dimensions,
- None,
- img_type=img_type)
+ warp_matrices,
+ motion_type,
+ cropped_dimensions,
+ match_index,
+ img_type=img_type)
return self.__aligned_capture
def aligned_shape(self):
+ """
+ Get aligned_capture ndarray shape.
+ :return: Tuple of array dimensions for aligned_capture
+ """
if self.__aligned_capture is None:
- raise RuntimeError("call Capture.create_aligned_capture prior to saving as stack")
+ raise RuntimeError("Call Capture.create_aligned_capture() prior to saving as stack.")
return self.__aligned_capture.shape
- def save_capture_as_stack(self, outfilename, sort_by_wavelength=False,photometric='MINISBLACK'):
+ def radiometric_pan_sharpened_aligned_capture(self, warp_matrices=None, irradiance_list=None, img_type: str = ''):
+ if irradiance_list is None and self.dls_irradiance() is None:
+ self.compute_undistorted_radiance()
+ img_type = 'radiance'
+ elif img_type == 'reflectance' and irradiance_list is not None:
+ self.compute_undistorted_reflectance(irradiance_list)
+ elif irradiance_list is None:
+ irradiance_list = self.dls_irradiance() + [0]
+ self.compute_undistorted_reflectance(irradiance_list)
+ img_type = 'reflectance'
+ self.__aligned_radiometric_pan_sharpened_capture = imageutils.radiometric_pan_sharpen(self,
+ warp_matrices=warp_matrices,
+ irradiance_list=irradiance_list)
+ return self.__aligned_radiometric_pan_sharpened_capture
+
+ def save_capture_as_stack(self, outfilename, sort_by_wavelength=False, photometric='MINISBLACK', pansharpen=False,
+ write_exif=True):
+ """
+ Output the Images in the Capture object as GTiff image stack.
+ :param out_file_name: str system file path
+ :param sort_by_wavelength: boolean
+ :param photometric: str GDAL argument for GTiff color matching
+ """
from osgeo.gdal import GetDriverByName, GDT_UInt16
- if self.__aligned_capture is None:
- raise RuntimeError("call Capture.create_aligned_capture prior to saving as stack")
-
- rows, cols, bands = self.__aligned_capture.shape
+ from osgeo import gdal
+ gdal.UseExceptions()
+
+ if self.__aligned_capture is None and self.__aligned_radiometric_pan_sharpened_capture is None:
+ raise RuntimeError(
+ "Call Capture.create_aligned_capture() prior to saving as stack.")
+ band_names = self.band_names()
+ if "Panchro" in band_names and pansharpen:
+ aligned_cap = self.__aligned_radiometric_pan_sharpened_capture[0]
+ if "Panchro" in band_names and not pansharpen:
+ aligned_cap = self.__aligned_radiometric_pan_sharpened_capture[1]
+ if "Panchro" not in band_names:
+ aligned_cap = self.__aligned_capture
+
+ rows, cols, bands = aligned_cap.shape
driver = GetDriverByName('GTiff')
-
- outRaster = driver.Create(outfilename, cols, rows, bands, GDT_UInt16, options = [ 'INTERLEAVE=BAND','COMPRESS=DEFLATE',f'PHOTOMETRIC={photometric}' ])
+
+ outRaster = driver.Create(outfilename, cols, rows, bands, GDT_UInt16,
+ options=['INTERLEAVE=BAND', 'COMPRESS=DEFLATE', f'PHOTOMETRIC={photometric}'])
try:
if outRaster is None:
raise IOError("could not load gdal GeoTiff driver")
if sort_by_wavelength:
eo_list = list(np.argsort(np.array(self.center_wavelengths())[self.eo_indices()]))
+ eo_bands = list(np.array(self.eo_band_names())[np.array(eo_list)])
+
else:
eo_list = self.eo_indices()
-
- for outband,inband in enumerate(eo_list):
- outband = outRaster.GetRasterBand(outband+1)
- outdata = self.__aligned_capture[:,:,inband]
- outdata[outdata<0] = 0
- outdata[outdata>2] = 2 #limit reflectance data to 200% to allow some specular reflections
- outband.WriteArray(outdata*32768) # scale reflectance images so 100% = 32768
+ eo_bands = list(np.array(self.eo_band_names())[np.array(eo_list)])
+
+ eo_count = len(eo_list)
+
+ for outband_count, inband in enumerate(eo_list):
+ outband = outRaster.GetRasterBand(outband_count + 1)
+ outdata = aligned_cap[:, :, inband]
+ outdata[outdata < 0] = 0
+ outdata[outdata > 2] = 2 # limit reflectance data to 200% to allow some specular reflections
+ outdata = outdata * 32767 # scale reflectance images so 100% = 32768
+ outdata = outdata.astype(np.ushort)
+ outband.SetDescription(eo_bands[outband_count])
+ outband.WriteArray(outdata)
outband.FlushCache()
- for outband,inband in enumerate(self.lw_indices()):
- outband = outRaster.GetRasterBand(len(eo_list)+outband+1)
- outdata = (self.__aligned_capture[:,:,inband]+273.15) * 100 # scale data from float degC to back to centi-Kelvin to fit into uint16
- outdata[outdata<0] = 0
- outdata[outdata>65535] = 65535
+ for outband_count, inband in enumerate(self.lw_indices()):
+ outband = outRaster.GetRasterBand(len(eo_bands) + outband_count + 1)
+ outdata = (aligned_cap[:, :,
+ inband] + 273.15) * 100 # scale data from float degC to back to centi-Kelvin to fit into uint16
+ outdata[outdata < 0] = 0
+ outdata[outdata > 65535] = 65535
+ outdata = outdata.astype(np.ushort)
+ outband.SetDescription('LWIR')
outband.WriteArray(outdata)
outband.FlushCache()
finally:
- outRaster = None
-
- 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 )
+ outRaster.Close()
+ if write_exif:
+ imageutils.write_exif_to_stack(self, outfilename)
+
+ 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=None):
+ """
+ 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 rgb_band_indices is None:
+ rgb_band_indices = [2, 1, 0]
+ if self.__aligned_capture is None and self.__aligned_radiometric_pan_sharpened_capture is None:
+ raise RuntimeError(
+ "Call Capture.create_aligned_capture or Capture.radiometric_pan_sharpened_aligned_capture prior to saving as RGB.")
+ if self.__aligned_radiometric_pan_sharpened_capture:
+ aligned_capture = self.__aligned_radiometric_pan_sharpened_capture[0]
+ else:
+ aligned_capture = self.__aligned_capture
+ im_display = np.zeros((aligned_capture.shape[0], aligned_capture.shape[1], 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
+ im_min = np.percentile(aligned_capture[:, :, rgb_band_indices].flatten(),
+ hist_min_percent) # modify these percentiles to adjust contrast
+ im_max = np.percentile(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)
+ im_display[:, :, i] = imageutils.normalize(aligned_capture[:, :, i], im_min, im_max)
else:
- im_display[:,:,i] = imageutils.normalize(self.__aligned_capture[:,:,i])
+ im_display[:, :, i] = imageutils.normalize(aligned_capture[:, :, i])
- rgb = im_display[:,:,rgb_band_indices]
- rgb = cv2.resize(rgb, None, fx=1/downsample, fy=1/downsample, interpolation=cv2.INTER_AREA)
+ 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
+ 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
+ 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'))
+ 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_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
+ imageio.imwrite(outfilename, (255 * unsharp_rgb).astype('uint8'))
+
+ def save_thermal_over_rgb(self, outfilename, figsize=(30, 23), lw_index=None, hist_min_percent=0.2,
+ hist_max_percent=99.8):
+ """
+ Output the Images in the Capture object as thermal over RGB.
+ :param out_file_name: str system file path.
+ :param fig_size: Tuple dimensions of the figure.
+ :param lw_index: int Index of LWIR Image in Capture.
+ :param hist_min_percent: float Minimum histogram percentile.
+ :param hist_max_percent: float Maximum histogram percentile.
+ """
+ if self.__aligned_capture is None and self.__aligned_radiometric_pan_sharpened_capture is None:
+ raise RuntimeError(
+ "Call Capture.create_aligned_capture or Capture.radiometric_pan_sharpened_aligned_capture prior to "
+ "saving as RGB.")
+ if self.__aligned_radiometric_pan_sharpened_capture:
+ aligned_capture = self.__aligned_radiometric_pan_sharpened_capture[0]
+ else:
+ aligned_capture = self.__aligned_capture
+ # 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 )
+ masked_thermal = aligned_capture[:, :, lw_index]
+
+ im_display = np.zeros((aligned_capture.shape[0], 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)
+ # 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(aligned_capture[:, :, rgb_band_indices].flatten(),
+ hist_min_percent) # modify these percentiles to adjust contrast
+ im_max = np.percentile(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(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)
+ 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 output(stack, gamma, channel_order=None):
+ if channel_order is None:
+ channel_order = [2, 1, 0]
+ out = stack[:, :, channel_order]
+ out -= out.min()
+ out /= out.max()
+ out = out ** gamma
+ scale = out.max()
+ return out / scale
+
+ @staticmethod
+ def find_inliers(kp_image, kp_ref, matches, *, random_seed: int = 9):
+
+ rng = np.random.default_rng(random_seed)
+ model, inliers = ransac((kp_image[matches[:, 0]],
+ kp_ref[matches[:, 1]]),
+ FundamentalMatrixTransform, min_samples=8,
+ residual_threshold=.25, max_trials=5000,
+ random_state=rng)
+ inlier_keypoints_image = kp_image[matches[inliers, 0]]
+ inlier_keypoints_ref = kp_ref[matches[inliers, 1]]
+ n = len(inlier_keypoints_ref)
+ return inlier_keypoints_image, inlier_keypoints_ref, np.array([np.arange(n), np.arange(n)]).T, model
+
+ KeyPoints = namedtuple('KeyPoints', ['kpi', 'kpr', 'match', 'err'])
+
+ @staticmethod
+ def filter_keypoints(kp_image, kp_ref, match, w, scale, scale_i, threshold: float = 1.0) -> KeyPoints:
+ err = []
+ P0 = ProjectiveTransform(matrix=w)
+ new_kpi = []
+ new_kpr = []
+ new_match = []
+ cnt = 0
+ for m in match:
+ # unfortunately the coordinates between skimage and our images are reversed
+ a = (kp_ref[m[1]] * scale)[::-1]
+ b = (kp_image[m[0]] * scale_i)[::-1]
+ e = (np.linalg.norm(P0(a) - b)) # error in pixels
+ if e < threshold:
+ new_kpi.append(kp_image[m[0]])
+ new_kpr.append(kp_ref[m[1]])
+ new_match.append([cnt, cnt])
+ cnt += 1
+ err.append(e)
+ return np.array(new_kpi), np.array(new_kpr), np.array(new_match), np.array(err)
+
+ def SIFT_align_capture(self, ref=5, min_matches=10, verbose=0, err_red=10.0, err_blue=12.0,
+ err_LWIR=12.):
+ descriptor_extractor = SIFT()
+ keypoints = []
+ descriptors = []
+ img_index = list(range(len(self.images)))
+ img_index.pop(ref)
+ ref_shape = self.images[ref].raw().shape
+ rest_shape = self.images[img_index[0]].raw().shape
+ scale = np.array(ref_shape) / np.array(rest_shape)
+
+ # use the calibrated warp matrices to verify keypoints
+ warp_matrices_calibrated = self.get_warp_matrices(ref_index=ref)
+
+ if not rest_shape == ref_shape:
+ ref_image_SIFT = resize(self.images[ref].undistorted(
+ self.images[ref].raw()), rest_shape)
+ ref_image_SIFT = (ref_image_SIFT / ref_image_SIFT.max()
+ * 65535).astype(np.uint16)
+
+ descriptor_extractor.detect_and_extract(ref_image_SIFT)
+ keypoints_ref = descriptor_extractor.keypoints
+ descriptor_ref = descriptor_extractor.descriptors
+ if verbose > 1:
+ print('found {:d} keypoints in the reference image'.format(len(keypoints_ref)))
+ match_images = []
+ ratio = []
+ filter_tr = []
+ img_index = np.array(img_index)
+ # extract keypoints % descriptors
+ for ix in img_index:
+ img = self.images[ix].undistorted(self.images[ix].raw())
+ if not img.shape == rest_shape:
+ # if we have a thermal image, upsample to match the resolution of the multispec images
+ img_base = self.images[ix].raw()[self.images[ix].raw() > 0].min()
+ img = img.astype(float)
+ img[img > 0] = img[img > 0] - img_base
+ img = resize(img, rest_shape)
+ img = (img / img.max() * 65535).astype(np.uint16)
+ ratio.append(1)
+ filter_tr.append(err_LWIR)
+ else:
+ ratio.append(0.8)
+ if ix <= 5:
+ filter_tr.append(err_red)
+ else:
+ # less strict filtering for the BLUE images
+ filter_tr.append(err_blue)
+ match_images.append(img)
+ descriptor_extractor.detect_and_extract(img)
+ keypoints.append(descriptor_extractor.keypoints)
+ descriptors.append(descriptor_extractor.descriptors)
+ if verbose > 1:
+ for k, ix in zip(keypoints, img_index):
+ print('found {:d} keypoints for band {:} '.format(len(k), self.images[ix].band_name))
+ print(' in the remaining stack')
+
+ matches = [match_descriptors(d, descriptor_ref, max_ratio=r)
+ for d, r in zip(descriptors, ratio)]
+
+ # do we have dual camera capture?
+ if len(img_index) > 9:
+ # if yes, we first match the first channel to the reference
+ img_index_Blue = img_index[img_index > 5]
+ iBlueREF = img_index_Blue[0]
+ # get the warp matrices for the BLUE reference
+ warpBLUE = self.get_warp_matrices(ref_index=iBlueREF)
+ # this is clunky, since we made our keypoint list WITHOUT the reference - consider refactoring that
+ posBLUE = np.where(img_index == iBlueREF)[0][0]
+ # we don't know the rig relatives between iBlueREF and ref
+ # so we have to rely on SIFT to find the correct transform
+ kpi, kpr, imatch, model = self.find_inliers(
+ keypoints[posBLUE], keypoints_ref, matches[posBLUE])
+ # we trust this match to work
+ if len(kpi) < min_matches:
+ print('we have just {:d} matching keypoints -the match of BLUE camera to RED failed!!'.format(len(kpi)))
+ # if it worked, scale it and get the transform
+ scale_i = np.array(self.images[iBlueREF].raw().shape) / np.array(rest_shape)
+ P = estimate_transform('projective', (scale * kpr)[:, ::-1], (scale_i * kpi)[:, ::-1])
+ warp_blue_ref = P.params
+ # now modify the BLUE warp matrices
+ for ix in img_index_Blue:
+ warp_matrices_calibrated[ix] = np.dot(warp_blue_ref, warpBLUE[ix])
+
+ models = []
+ kp_image = []
+ kp_ref = []
+ for m, k, ix, t in zip(matches, keypoints, img_index, filter_tr):
+ # we need to down scale the thermal image for the proper transform
+ scale_i = np.array(self.images[ix].raw().shape) / np.array(rest_shape)
+
+ filtered_kpi, filtered_kpr, filtered_match, err = self.filter_keypoints(k,
+ keypoints_ref,
+ m,
+ warp_matrices_calibrated[ix],
+ scale,
+ scale_i,
+ threshold=t)
+ if verbose > 0:
+ print('found {:d} matching keypoints for index {:d}'.format(len(filtered_match), ix))
+ # if we have enough SIFT matches that actually correspond, compute a model
+ if len(filtered_match) > min_matches:
+ kpi, kpr, imatch, model = self.find_inliers(filtered_kpi,
+ filtered_kpr,
+ filtered_match)
+
+ P = estimate_transform(
+ 'projective', (scale * kpr)[:, ::-1], (scale_i * kpi)[:, ::-1])
+ # otherwise, use the calibrated matrix
+ # most of the time this will occur for the thermal image, as we have a hard time
+ # finding a good matches between panchro & thermal in most cases
+ else:
+ P = ProjectiveTransform(matrix=warp_matrices_calibrated[ix])
+ if verbose > 0:
+ print('no match for index {:d}'.format(ix))
+ models.append(P)
+ kp_image.append(kpi)
+ kp_ref.append(kpr)
+ img = self.images[ix].undistorted(self.images[ix].raw())
+
+ # no need for the upsampled stacks here
+ if verbose > 0:
+ print("Finished aligning band", ix)
+
+ self.__sift_aligned_capture = [np.eye(3)] * len(self.images)
+ for ix, m in zip(img_index, models):
+ self.__sift_aligned_capture[ix] = m.params
+
+ return self.__sift_aligned_capture
+
+ def adjust_transform(self, ref_index):
+ warp_matrices = self.get_warp_matrices(ref_index=ref_index)
+ t_matrices = []
+ CR = self.images[ref_index].cv2_camera_matrix()
+ for i in self.images:
+ z = i.location[2] * 1e3
+ C = i.cv2_camera_matrix()
+
+ T = (np.array(i.rig_translations) - np.array(self.images[ref_index].rig_translations))
+ tm = np.eye(3)
+ tm[0, 2] = C[0, 0] * T[0] / z
+ tm[1, 2] = C[1, 1] * T[1] / z
+ t_matrices.append(tm)
+ warp_new = [np.dot(t, w) for w, t in zip(warp_matrices, t_matrices)]
+ return warp_new
diff --git a/micasense/dls.py b/micasense/dls.py
index 44a45191..e8a154fd 100644
--- a/micasense/dls.py
+++ b/micasense/dls.py
@@ -23,36 +23,41 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-
import numpy as np
+
# for DLS correction, we need the sun position at the time the image was taken
# this can be computed using the pysolar package (ver 0.6)
# https://pypi.python.org/pypi/Pysolar/0.6
# we import multiple times with checking here because the case of Pysolar is
# different depending on the python version :(
-import imp
+# import imp
havePysolar = False
try:
import pysolar.solar as pysolar
+
havePysolar = True
except ImportError:
try:
import Pysolar.solar as pysolar
+
havePysolar = True
except ImportError:
import pysolar.solar as pysolar
- havePysolar = True
-finally:
+
+ havePysolar = True
+finally:
if not havePysolar:
print("Unable to import pysolar")
+
def fresnel(phi):
- return __multilayer_transmission(phi, n=[1.000277,1.6,1.38])
+ return __multilayer_transmission(phi, n=[1.000277, 1.6, 1.38])
+
# define functions to compute the DLS-Sun angle:
-def __fresnel_transmission(phi, n1=1.000277, n2=1.38, polarization=[.5, .5]):
+def __fresnel_transmission(phi, n1=1.000277, n2=1.38, polarization=None):
"""compute fresnel transmission between media with refractive indices n1 and n2"""
# computes the reflection and transmittance
# for incidence angles phi for transition from medium
@@ -62,36 +67,46 @@ def __fresnel_transmission(phi, n1=1.000277, n2=1.38, polarization=[.5, .5]):
# polarization=[.5,.5] - unpolarized light
# polarization=[1.,0] - s-polarized light - perpendicular to plane of incidence
# polarization=[0,1.] - p-polarized light - parallel to plane of incidence
+ if polarization is None:
+ polarization = [.5, .5]
f1 = np.cos(phi)
- f2 = np.sqrt(1-(n1/n2*np.sin(phi))**2)
- Rs = ((n1*f1-n2*f2)/(n1*f1+n2*f2))**2
- Rp = ((n1*f2-n2*f1)/(n1*f2+n2*f1))**2
- T = 1.-polarization[0]*Rs-polarization[1]*Rp
- if T > 1: T= 0.
- if T < 0: T = 0.
- if np.isnan(T): T = 0.
+ f2 = np.sqrt(1 - (n1 / n2 * np.sin(phi)) ** 2)
+ Rs = ((n1 * f1 - n2 * f2) / (n1 * f1 + n2 * f2)) ** 2
+ Rp = ((n1 * f2 - n2 * f1) / (n1 * f2 + n2 * f1)) ** 2
+ T = 1. - polarization[0] * Rs - polarization[1] * Rp
+ if T > 1:
+ T = 0.
+ if T < 0:
+ T = 0.
+ if np.isnan(T):
+ T = 0.
return T
-def __multilayer_transmission(phi, n, polarization=[.5, .5]):
+
+def __multilayer_transmission(phi, n, polarization=None):
+ if polarization is None:
+ polarization = [.5, .5]
T = 1.0
phi_eff = np.copy(phi)
- for i in range(0,len(n)-1):
+ for i in range(0, len(n) - 1):
n1 = n[i]
- n2 = n[i+1]
- phi_eff = np.arcsin(np.sin(phi_eff)/n1)
+ n2 = n[i + 1]
+ phi_eff = np.arcsin(np.sin(phi_eff) / n1)
T *= __fresnel_transmission(phi_eff, n1, n2, polarization=polarization)
return T
+
# get the position of the sun in North-East-Down (NED) coordinate system
-def ned_from_pysolar(sunAzimuth, sunAltitude):
+def ned_from_pysolar(sun_azimuth, sun_altitude):
"""Convert pysolar coordinates to NED coordinates."""
elements = (
- np.cos(sunAzimuth) * np.cos(sunAltitude),
- np.sin(sunAzimuth) * np.cos(sunAltitude),
- -np.sin(sunAltitude),
+ np.cos(sun_azimuth) * np.cos(sun_altitude),
+ np.sin(sun_azimuth) * np.cos(sun_altitude),
+ -np.sin(sun_altitude),
)
return np.array(elements).transpose()
+
# get the sensor orientation in North-East-Down coordinates
# pose is a yaw/pitch/roll tuple of angles measured for the DLS
# ori is the 3D orientation vector of the DLS in body coordinates (typically [0,0,-1])
@@ -111,6 +126,7 @@ def get_orientation(pose, ori):
n = np.dot(R, ori)
return n
+
# from the current position (lat,lon,alt) tuple
# and time (UTC), as well as the sensor orientation (yaw,pitch,roll) tuple
# compute a sensor sun angle - this is needed as the actual sun irradiance
@@ -121,26 +137,24 @@ def get_orientation(pose, ori):
# I_measured = I_direct * (cos (sun_sensor_angle) + 1/6)
def compute_sun_angle(
- position,
- pose,
- utc_datetime,
- sensor_orientation,
+ position,
+ pose,
+ utc_datetime,
+ sensor_orientation,
):
""" compute the sun angle using pysolar functions"""
- altitude = 0
- azimuth = 0
import warnings
- with warnings.catch_warnings(): # Ignore pysolar leap seconds offset warning
+ with warnings.catch_warnings(): # Ignore pysolar leap seconds offset warning
warnings.simplefilter("ignore")
try:
altitude = pysolar.get_altitude(position[0], position[1], utc_datetime)
azimuth = pysolar.get_azimuth(position[0], position[1], utc_datetime)
- except AttributeError: # catch 0.6 version of pysolar required for python 2.7 support
+ except AttributeError: # catch 0.6 version of pysolar required for python 2.7 support
altitude = pysolar.GetAltitude(position[0], position[1], utc_datetime)
- azimuth = 180-pysolar.GetAzimuth(position[0], position[1], utc_datetime)
+ azimuth = 180 - pysolar.GetAzimuth(position[0], position[1], utc_datetime)
sunAltitude = np.radians(np.array(altitude))
sunAzimuth = np.radians(np.array(azimuth))
- sunAzimuth = sunAzimuth % (2 * np.pi ) #wrap range 0 to 2*pi
+ sunAzimuth = sunAzimuth % (2 * np.pi) # wrap range 0 to 2*pi
nSun = ned_from_pysolar(sunAzimuth, sunAltitude)
nSensor = np.array(get_orientation(pose, sensor_orientation))
angle = np.arccos(np.dot(nSun, nSensor))
diff --git a/micasense/image.py b/micasense/image.py
index 80e8271f..d12fb569 100644
--- a/micasense/image.py
+++ b/micasense/image.py
@@ -26,43 +26,46 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
+import math
import os
+
import cv2
-import math
import numpy as np
-import matplotlib.pyplot as plt
-import micasense.plotutils as plotutils
-import micasense.metadata as metadata
import micasense.dls as dls
+import micasense.metadata as metadata
+import micasense.plotutils as plotutils
+
-#helper function to convert euler angles to a rotation matrix
+# helper function to convert euler angles to a rotation matrix
def rotations_degrees_to_rotation_matrix(rotation_degrees):
- cx = np.cos(np.deg2rad(rotation_degrees[0]))
- cy = np.cos(np.deg2rad(rotation_degrees[1]))
- cz = np.cos(np.deg2rad(rotation_degrees[2]))
- sx = np.sin(np.deg2rad(rotation_degrees[0]))
- sy = np.sin(np.deg2rad(rotation_degrees[1]))
- sz = np.sin(np.deg2rad(rotation_degrees[2]))
-
- Rx = np.mat([ 1, 0, 0,
- 0, cx,-sx,
- 0, sx, cx]).reshape(3,3)
- Ry = np.mat([ cy, 0, sy,
- 0, 1, 0,
- -sy, 0, cy]).reshape(3,3)
- Rz = np.mat([ cz,-sz, 0,
- sz, cz, 0,
- 0, 0, 1]).reshape(3,3)
- R = Rx*Ry*Rz
- return R
+ cx = np.cos(np.deg2rad(rotation_degrees[0]))
+ cy = np.cos(np.deg2rad(rotation_degrees[1]))
+ cz = np.cos(np.deg2rad(rotation_degrees[2]))
+ sx = np.sin(np.deg2rad(rotation_degrees[0]))
+ sy = np.sin(np.deg2rad(rotation_degrees[1]))
+ sz = np.sin(np.deg2rad(rotation_degrees[2]))
+
+ Rx = np.mat([1, 0, 0,
+ 0, cx, -sx,
+ 0, sx, cx]).reshape(3, 3)
+ Ry = np.mat([cy, 0, sy,
+ 0, 1, 0,
+ -sy, 0, cy]).reshape(3, 3)
+ Rz = np.mat([cz, -sz, 0,
+ sz, cz, 0,
+ 0, 0, 1]).reshape(3, 3)
+ R = Rx * Ry * Rz
+ return R
+
class Image(object):
"""
An Image is a single file taken by a RedEdge camera representing one
band of multispectral information
"""
- def __init__(self, image_path, exiftool_obj=None):
+
+ def __init__(self, image_path: str, exiftool_obj=None, allow_uncalibrated=False):
if not os.path.isfile(image_path):
raise IOError("Provided path is not a file: {}".format(image_path))
self.path = image_path
@@ -70,16 +73,20 @@ def __init__(self, image_path, exiftool_obj=None):
if self.meta.band_name() is None:
raise ValueError("Provided file path does not have a band name: {}".format(image_path))
- if self.meta.band_name().upper() != 'LWIR' and not self.meta.supports_radiometric_calibration():
- raise ValueError('Library requires images taken with RedEdge-(3/M/MX) camera firmware v2.1.0 or later. ' +
- 'Upgrade your camera firmware to at least version 2.1.0 to use this library with RedEdge-(3/M/MX) cameras.')
-
+ if not allow_uncalibrated:
+ if self.meta.band_name().upper() != 'LWIR' and not self.meta.supports_radiometric_calibration():
+ raise ValueError(
+ 'Library requires images taken with RedEdge-(3/M/MX) camera firmware v2.1.0 or later. ' +
+ 'Upgrade your camera firmware to at least version 2.1.0 to use this library with RedEdge-(3/M/MX) cameras.')
+ self.allow_uncalibrated = allow_uncalibrated
self.utc_time = self.meta.utc_time()
self.latitude, self.longitude, self.altitude = self.meta.position()
self.location = (self.latitude, self.longitude, self.altitude)
self.dls_present = self.meta.dls_present()
self.dls_yaw, self.dls_pitch, self.dls_roll = self.meta.dls_pose()
self.capture_id = self.meta.capture_id()
+ self.camera_model = self.meta.camera_model()
+ self.camera_serial = self.meta.camera_serial()
self.flight_id = self.meta.flight_id()
self.band_name = self.meta.band_name()
self.band_index = self.meta.band_index()
@@ -90,8 +97,13 @@ def __init__(self, image_path, exiftool_obj=None):
self.gain = self.meta.gain()
self.bits_per_pixel = self.meta.bits_per_pixel()
+ # vignette can be either a radial poly or a 2D polynomial
self.vignette_center = self.meta.vignette_center()
self.vignette_polynomial = self.meta.vignette_polynomial()
+
+ self.vignette_polynomial2Dexponents = self.meta.vignette_polynomial2Dexponents()
+ self.vignette_polynomial2D = self.meta.vignette_polynomial2D()
+
self.distortion_parameters = self.meta.distortion_parameters()
self.principal_point = self.meta.principal_point()
self.focal_plane_resolution_px_per_mm = self.meta.focal_plane_resolution_px_per_mm()
@@ -100,6 +112,7 @@ def __init__(self, image_path, exiftool_obj=None):
self.center_wavelength = self.meta.center_wavelength()
self.bandwidth = self.meta.bandwidth()
self.rig_relatives = self.meta.rig_relatives()
+ self.rig_translations = self.meta.rig_translations()
self.spectral_irradiance = self.meta.spectral_irradiance()
self.auto_calibration_image = self.meta.auto_calibration_image()
@@ -108,15 +121,15 @@ def __init__(self, image_path, exiftool_obj=None):
self.panel_serial = self.meta.panel_serial()
if self.dls_present:
- self.dls_orientation_vector = np.array([0,0,-1])
+ self.dls_orientation_vector = np.array([0, 0, -1])
self.sun_vector_ned, \
- self.sensor_vector_ned, \
- self.sun_sensor_angle, \
- self.solar_elevation, \
- self.solar_azimuth=dls.compute_sun_angle(self.location,
- self.meta.dls_pose(),
- self.utc_time,
- self.dls_orientation_vector)
+ self.sensor_vector_ned, \
+ self.sun_sensor_angle, \
+ self.solar_elevation, \
+ self.solar_azimuth = dls.compute_sun_angle(self.location,
+ self.meta.dls_pose(),
+ self.utc_time,
+ self.dls_orientation_vector)
self.angular_correction = dls.fresnel(self.sun_sensor_angle)
# when we have good horizontal irradiance the camera provides the solar az and el also
@@ -129,63 +142,63 @@ def __init__(self, image_path, exiftool_obj=None):
self.estimated_direct_vector = self.meta.estimated_direct_vector()
if self.meta.horizontal_irradiance_valid():
self.horizontal_irradiance = self.meta.horizontal_irradiance()
- else:
+ else:
self.horizontal_irradiance = self.compute_horizontal_irradiance_dls2()
else:
- self.direct_to_diffuse_ratio = 6.0 # assumption
+ self.direct_to_diffuse_ratio = 6.0 # assumption
self.horizontal_irradiance = self.compute_horizontal_irradiance_dls1()
self.spectral_irradiance = self.meta.spectral_irradiance()
- else: # no dls present or LWIR band: compute what we can, set the rest to 0
- self.dls_orientation_vector = np.array([0,0,-1])
+ else: # no dls present or LWIR band: compute what we can, set the rest to 0
+ self.dls_orientation_vector = np.array([0, 0, -1])
self.sun_vector_ned, \
- self.sensor_vector_ned, \
- self.sun_sensor_angle, \
- self.solar_elevation, \
- self.solar_azimuth=dls.compute_sun_angle(self.location,
- (0,0,0),
- self.utc_time,
- self.dls_orientation_vector)
+ self.sensor_vector_ned, \
+ self.sun_sensor_angle, \
+ self.solar_elevation, \
+ self.solar_azimuth = dls.compute_sun_angle(self.location,
+ (0, 0, 0),
+ self.utc_time,
+ self.dls_orientation_vector)
self.angular_correction = dls.fresnel(self.sun_sensor_angle)
self.horizontal_irradiance = 0
self.scattered_irradiance = 0
self.direct_irradiance = 0
self.direct_to_diffuse_ratio = 0
-
+
# Internal image containers; these can use a lot of memory, clear with Image.clear_images
- self.__raw_image = None # pure raw pixels
- self.__intensity_image = None # black level and gain-exposure/radiometric compensated
- self.__radiance_image = None # calibrated to radiance
- self.__reflectance_image = None # calibrated to reflectance (0-1)
+ self.__raw_image = None # pure raw pixels
+ self.__intensity_image = None # black level and gain-exposure/radiometric compensated
+ self.__radiance_image = None # calibrated to radiance
+ self.__reflectance_image = None # calibrated to reflectance (0-1)
self.__reflectance_irradiance = None
- self.__undistorted_source = None # can be any of raw, intensity, radiance
- self.__undistorted_image = None # current undistorted image, depdining on source
+ self.__undistorted_source = None # can be any of raw, intensity, radiance
+ self.__undistorted_image = None # current undistorted image, depdining on source
- # solar elevation is defined as the angle betwee the horizon and the sun, so it is 0 when the
+ # solar elevation is defined as the angle between the horizon and the sun, so it is 0 when the
# sun is at the horizon and pi/2 when the sun is directly overhead
def horizontal_irradiance_from_direct_scattered(self):
return self.direct_irradiance * np.sin(self.solar_elevation) + self.scattered_irradiance
def compute_horizontal_irradiance_dls1(self):
- percent_diffuse = 1.0/self.direct_to_diffuse_ratio
- #percent_diffuse = 5e4/(img.center_wavelength**2)
+ percent_diffuse = 1.0 / self.direct_to_diffuse_ratio
+ # percent_diffuse = 5e4/(img.center_wavelength**2)
sensor_irradiance = self.spectral_irradiance / self.angular_correction
# find direct irradiance in the plane normal to the sun
untilted_direct_irr = sensor_irradiance / (percent_diffuse + np.cos(self.sun_sensor_angle))
self.direct_irradiance = untilted_direct_irr
- self.scattered_irradiance = untilted_direct_irr*percent_diffuse
+ self.scattered_irradiance = untilted_direct_irr * percent_diffuse
# compute irradiance on the ground using the solar altitude angle
return self.horizontal_irradiance_from_direct_scattered()
-
+
def compute_horizontal_irradiance_dls2(self):
- ''' Compute the proper solar elevation, solar azimuth, and horizontal irradiance
- for cases where the camera system did not do it correctly '''
- _,_,_, \
- self.solar_elevation, \
- self.solar_azimuth=dls.compute_sun_angle(self.location,
- (0,0,0),
- self.utc_time,
- np.array([0,0,-1]))
+ """ Compute the proper solar elevation, solar azimuth, and horizontal irradiance
+ for cases where the camera system did not do it correctly """
+ _, _, _, \
+ self.solar_elevation, \
+ self.solar_azimuth = dls.compute_sun_angle(self.location,
+ (0, 0, 0),
+ self.utc_time,
+ np.array([0, 0, -1]))
return self.horizontal_irradiance_from_direct_scattered()
def __lt__(self, other):
@@ -196,39 +209,51 @@ def __gt__(self, other):
def __eq__(self, other):
return (self.band_index == other.band_index) and \
- (self.capture_id == other.capture_id)
+ (self.capture_id == other.capture_id)
def __ne__(self, other):
return (self.band_index != other.band_index) or \
- (self.capture_id != other.capture_id)
+ (self.capture_id != other.capture_id)
def raw(self):
- ''' Lazy load the raw image once neecessary '''
+ """ Lazy load the raw image once necessary """
if self.__raw_image is None:
try:
import rawpy
- self.__raw_image = rawpy.imread(self.path).raw_image
+ # to support 12-bit DNG files, otherwise we get "SIFT found no features" error
+ if self.bits_per_pixel == 12:
+ self.__raw_image = rawpy.imread(self.path).raw_image * 16
+ else:
+ self.__raw_image = rawpy.imread(self.path).raw_image
except ImportError:
- self.__raw_image = cv2.imread(self.path,-1)
+ self.__raw_image = cv2.imread(self.path, -1)
except IOError:
- print("Could not open image at path {}".format(self.path))
+ print(("Could not open image at path {}".format(self.path)))
raise
return self.__raw_image
- def set_external_rig_relatives(self,external_rig_relatives):
+ def set_raw(self, img):
+ """ set raw image from input img"""
+ self.__raw_image = img.astype(np.uint16)
+
+ def set_undistorted(self, img):
+ """ set undistorted image from input img"""
+ self.__undistorted_image = img.astype(np.uint16)
+
+ def set_external_rig_relatives(self, external_rig_relatives):
self.rig_translations = external_rig_relatives['rig_translations']
- #external rig relatives are in rad
+ # external rig relatives are in rad
self.rig_relatives = [np.rad2deg(a) for a in external_rig_relatives['rig_relatives']]
- px,py = external_rig_relatives['cx'],external_rig_relatives['cy']
- fx,fy = external_rig_relatives['fx'],external_rig_relatives['fy']
+ px, py = external_rig_relatives['cx'], external_rig_relatives['cy']
+ fx, fy = external_rig_relatives['fx'], external_rig_relatives['fy']
rx = self.focal_plane_resolution_px_per_mm[0]
ry = self.focal_plane_resolution_px_per_mm[1]
- self.principal_point = [px/rx,py/ry]
- self.focal_length = (fx+fy)*.5/rx
- #to do - set the distortion etc.
+ self.principal_point = [px / rx, py / ry]
+ self.focal_length = (fx + fy) * .5 / rx
+ # to do - set the distortion etc.
def clear_image_data(self):
- ''' clear all computed images to reduce memory overhead '''
+ """ clear all computed images to reduce memory overhead """
self.__raw_image = None
self.__intensity_image = None
self.__radiance_image = None
@@ -242,10 +267,10 @@ def size(self):
return width, height
def reflectance(self, irradiance=None, force_recompute=False):
- ''' Lazy-compute and return a reflectance image provided an irradiance reference '''
+ """ Lazy-compute and return a reflectance image provided an irradiance reference """
if self.__reflectance_image is not None \
- and force_recompute == False \
- and (self.__reflectance_irradiance == irradiance or irradiance == None):
+ and not force_recompute \
+ and (self.__reflectance_irradiance == irradiance or irradiance is None):
return self.__reflectance_image
if irradiance is None and self.band_name != 'LWIR':
if self.horizontal_irradiance != 0.0:
@@ -260,10 +285,10 @@ def reflectance(self, irradiance=None, force_recompute=False):
return self.__reflectance_image
def intensity(self, force_recompute=False):
- ''' Lazy=computes and returns the intensity image after black level,
+ """ Lazy=computes and returns the intensity image after black level,
vignette, and row correction applied.
- Intensity is in units of DN*Seconds without a radiance correction '''
- if self.__intensity_image is not None and force_recompute == False:
+ Intensity is in units of DN*Seconds without a radiance correction """
+ if self.__intensity_image is not None and not force_recompute:
return self.__intensity_image
# get image dimensions
@@ -277,22 +302,22 @@ def intensity(self, force_recompute=False):
R = 1.0 / (1.0 + a2 * y / self.exposure_time - a3 * y)
L = V * R * (image_raw - self.black_level)
L[L < 0] = 0
- max_raw_dn = float(2**self.bits_per_pixel)
- intensity_image = L.astype(float)/(self.gain * self.exposure_time * max_raw_dn)
+ max_raw_dn = float(2 ** self.bits_per_pixel)
+ intensity_image = L.astype(float) / (self.gain * self.exposure_time * max_raw_dn)
self.__intensity_image = intensity_image.T
return self.__intensity_image
def radiance(self, force_recompute=False):
- ''' Lazy=computes and returns the radiance image after all radiometric
- corrections have been applied '''
- if self.__radiance_image is not None and force_recompute == False:
+ """ Lazy=computes and returns the radiance image after all radiometric
+ corrections have been applied """
+ if self.__radiance_image is not None and not force_recompute:
return self.__radiance_image
# get image dimensions
image_raw = np.copy(self.raw()).T
- if(self.band_name != 'LWIR'):
+ if self.band_name != 'LWIR':
# get radiometric calibration factors
a1, a2, a3 = self.radiometric_cal[0], self.radiometric_cal[1], self.radiometric_cal[2]
# apply image correction methods to raw image
@@ -300,46 +325,60 @@ def radiance(self, force_recompute=False):
R = 1.0 / (1.0 + a2 * y / self.exposure_time - a3 * y)
L = V * R * (image_raw - self.black_level)
L[L < 0] = 0
- max_raw_dn = float(2**self.bits_per_pixel)
- radiance_image = L.astype(float)/(self.gain * self.exposure_time)*a1/max_raw_dn
+ max_raw_dn = float(2 ** self.bits_per_pixel)
+ radiance_image = L.astype(float) / (self.gain * self.exposure_time) * a1 / max_raw_dn
else:
- L = image_raw - (273.15*100.0) # convert to C from K
+ L = image_raw - (273.15 * 100.0) # convert to C from K
radiance_image = L.astype(float) * 0.01
self.__radiance_image = radiance_image.T
return self.__radiance_image
def vignette(self):
- ''' Get a numpy array which defines the value to multiply each pixel by to correct
+ """ Get a numpy array which defines the value to multiply each pixel by to correct
for optical vignetting effects.
Note: this array is transposed from normal image orientation and comes as part
of a three-tuple, the other parts of which are also used by the radiance method.
- '''
- # get vignette center
- vignette_center_x, vignette_center_y = self.vignette_center
-
- # get a copy of the vignette polynomial because we want to modify it here
- v_poly_list = list(self.vignette_polynomial)
-
- # reverse list and append 1., so that we can call with numpy polyval
- v_poly_list.reverse()
- v_poly_list.append(1.)
- v_polynomial = np.array(v_poly_list)
-
- # perform vignette correction
- # get coordinate grid across image, seem swapped because of transposed vignette
+ """
x_dim, y_dim = self.raw().shape[1], self.raw().shape[0]
+ # get coordinate grid across image, seem swapped because of transposed vignette
x, y = np.meshgrid(np.arange(x_dim), np.arange(y_dim))
-
- #meshgrid returns transposed arrays
+ # meshgrid returns transposed arrays
x = x.T
y = y.T
-
- # compute matrix of distances from image center
- r = np.hypot((x-vignette_center_x), (y-vignette_center_y))
-
- # compute the vignette polynomial for each distance - we divide by the polynomial so that the
- # corrected image is image_corrected = image_original * vignetteCorrection
- vignette = 1./np.polyval(v_polynomial, r)
+ # if we have a radial poly
+ if len(self.vignette_center) > 0:
+
+ # get vignette center
+
+ vignette_center_x, vignette_center_y = self.vignette_center
+
+ # get a copy of the vignette polynomial because we want to modify it here
+ v_poly_list = list(self.vignette_polynomial)
+
+ # reverse list and append 1., so that we can call with numpy polyval
+ v_poly_list.reverse()
+ v_poly_list.append(1.)
+ v_polynomial = np.array(v_poly_list)
+
+ # perform vignette correction
+
+ # compute matrix of distances from image center
+ r = np.hypot((x - vignette_center_x), (y - vignette_center_y))
+
+ # compute the vignette polynomial for each distance - we divide by the polynomial so that the
+ # corrected image is image_corrected = image_original * vignetteCorrection
+ vignette = 1. / np.polyval(v_polynomial, r)
+ elif len(self.vignette_polynomial2D) > 0:
+ xv = x.T / x_dim
+ yv = y.T / y_dim
+ k = self.vignette_polynomial2D
+ e = self.vignette_polynomial2Dexponents
+ p2 = np.zeros_like(xv, dtype=float)
+ for i, c in enumerate(k):
+ ex = e[2 * i]
+ ey = e[2 * i + 1]
+ p2 += c * xv ** ex * yv ** ey
+ vignette = (1. / p2).T
return vignette, x, y
def undistorted_radiance(self, force_recompute=False):
@@ -352,14 +391,14 @@ def plottable_vignette(self):
return self.vignette()[0].T
def cv2_distortion_coeff(self):
- #dist_coeffs = np.array(k[0],k[1],p[0],p[1],k[2]])
+ # dist_coeffs = np.array(k[0],k[1],p[0],p[1],k[2]])
return np.array(self.distortion_parameters)[[0, 1, 3, 4, 2]]
# values in pp are in [mm], rescale to pixels
def principal_point_px(self):
center_x = self.principal_point[0] * self.focal_plane_resolution_px_per_mm[0]
center_y = self.principal_point[1] * self.focal_plane_resolution_px_per_mm[1]
- return (center_x, center_y)
+ return center_x, center_y
def cv2_camera_matrix(self):
center_x, center_y = self.principal_point_px()
@@ -376,16 +415,16 @@ def cv2_camera_matrix(self):
return cam_mat
def rig_xy_offset_in_px(self):
- pixel_pitch_mm_x = 1.0/self.focal_plane_resolution_px_per_mm[0]
- pixel_pitch_mm_y = 1.0/self.focal_plane_resolution_px_per_mm[1]
- px_fov_x = 2.0 * math.atan2(pixel_pitch_mm_x/2.0, self.focal_length)
- px_fov_y = 2.0 * math.atan2(pixel_pitch_mm_y/2.0, self.focal_length)
+ pixel_pitch_mm_x = 1.0 / self.focal_plane_resolution_px_per_mm[0]
+ pixel_pitch_mm_y = 1.0 / self.focal_plane_resolution_px_per_mm[1]
+ px_fov_x = 2.0 * math.atan2(pixel_pitch_mm_x / 2.0, self.focal_length)
+ px_fov_y = 2.0 * math.atan2(pixel_pitch_mm_y / 2.0, self.focal_length)
t_x = math.radians(self.rig_relatives[0]) / px_fov_x
t_y = math.radians(self.rig_relatives[1]) / px_fov_y
- return (t_x, t_y)
+ return t_x, t_y
def undistorted(self, image):
- ''' return the undistorted image from input image '''
+ """ return the undistorted image from input image """
# If we have already undistorted the same source, just return that here
# otherwise, lazy compute the undstorted image
if self.__undistorted_source is not None and image.data == self.__undistorted_source.data:
@@ -398,81 +437,84 @@ def undistorted(self, image):
self.size(),
1)
map1, map2 = cv2.initUndistortRectifyMap(self.cv2_camera_matrix(),
- self.cv2_distortion_coeff(),
- np.eye(3),
- new_cam_mat,
- self.size(),
- cv2.CV_32F) # cv2.CV_32F for 32 bit floats
+ self.cv2_distortion_coeff(),
+ np.eye(3),
+ new_cam_mat,
+ self.size(),
+ cv2.CV_32F) # cv2.CV_32F for 32 bit floats
# compute the undistorted 16 bit image
self.__undistorted_image = cv2.remap(image, map1, map2, cv2.INTER_LINEAR)
return self.__undistorted_image
def plot_raw(self, title=None, figsize=None):
- ''' Create a single plot of the raw image '''
+ """ Create a single plot of the raw image """
if title is None:
title = '{} Band {} Raw DN'.format(self.band_name, self.band_index)
return plotutils.plotwithcolorbar(self.raw(), title=title, figsize=figsize)
def plot_intensity(self, title=None, figsize=None):
- ''' Create a single plot of the image converted to uncalibrated intensity '''
+ """ Create a single plot of the image converted to uncalibrated intensity """
if title is None:
title = '{} Band {} Intensity (DN*sec)'.format(self.band_name, self.band_index)
return plotutils.plotwithcolorbar(self.intensity(), title=title, figsize=figsize)
-
def plot_radiance(self, title=None, figsize=None):
- ''' Create a single plot of the image converted to radiance '''
+ """ Create a single plot of the image converted to radiance """
if title is None:
title = '{} Band {} Radiance'.format(self.band_name, self.band_index)
return plotutils.plotwithcolorbar(self.radiance(), title=title, figsize=figsize)
def plot_vignette(self, title=None, figsize=None):
- ''' Create a single plot of the vignette '''
+ """ Create a single plot of the vignette """
if title is None:
title = '{} Band {} Vignette'.format(self.band_name, self.band_index)
return plotutils.plotwithcolorbar(self.plottable_vignette(), title=title, figsize=figsize)
def plot_undistorted_radiance(self, title=None, figsize=None):
- ''' Create a single plot of the undistorted radiance '''
+ """ Create a single plot of the undistorted radiance """
if title is None:
title = '{} Band {} Undistorted Radiance'.format(self.band_name, self.band_index)
return plotutils.plotwithcolorbar(self.undistorted(self.radiance()), title=title, figsize=figsize)
- def plot_all(self, figsize=(13,10)):
+ def plot_all(self, figsize=(13, 10)):
plots = [self.raw(), self.plottable_vignette(), self.radiance(), self.undistorted(self.radiance())]
plot_types = ['Raw', 'Vignette', 'Radiance', 'Undistorted Radiance']
titles = ['{} Band {} {}'.format(str(self.band_name), str(self.band_index), tpe)
- for tpe in plot_types]
+ for tpe in plot_types]
plotutils.subplotwithcolorbar(2, 2, plots, titles, figsize=figsize)
- #get the homography that maps from this image to the reference image
- def get_homography(self,ref,R=None,T=None):
- #if we have externally supplied rotations/translations for the rig use these
+ # get the homography that maps from this image to the reference image
+
+ def get_homography(self, ref, R=None, T=None):
+ # if we have externally supplied rotations/translations for the rig use these
# otherwise use the rig-relatives intrinsic to the image
if R is None:
R = rotations_degrees_to_rotation_matrix(self.rig_relatives)
if T is None:
- T =np.zeros(3)
-
- A = np.zeros((4,4))
- A[0:3,0:3]=R
- A[0:3,3]=T
- A[3,3]=1.
+ T = np.zeros(3)
+ # don't want to use this here
+ # if self.rig_translations is not None:
+ # T = np.array(self.rig_translations)-np.array(ref.rig_translations)
+ R_ref = rotations_degrees_to_rotation_matrix(ref.rig_relatives)
+ A = np.zeros((4, 4))
+ A[0:3, 0:3] = np.dot(R_ref.T, R)
+ A[0:3, 3] = T
+ A[3, 3] = 1.
C, _ = cv2.getOptimalNewCameraMatrix(self.cv2_camera_matrix(),
self.cv2_distortion_coeff(),
- self.size(),1)
+ self.size(), 1)
Cr, _ = cv2.getOptimalNewCameraMatrix(ref.cv2_camera_matrix(),
ref.cv2_distortion_coeff(),
- ref.size(),1)
- CC = np.zeros((4,4))
- CC[0:3,0:3] = C
- CC[3,3]=1.
- CCr = np.zeros((4,4))
- CCr[0:3,0:3] = Cr
- CCr[3,3]=1.
-
- B = np.array(np.dot(CCr,np.dot(A,np.linalg.inv(CC))))
- B[:,2]=B[:,2]-B[:,3]
- B = B[0:3,0:3]
- B = B/B[2,2]
+ ref.size(), 1)
+ CC = np.zeros((4, 4))
+ CC[0:3, 0:3] = C
+ CC[3, 3] = 1.
+ CCr = np.zeros((4, 4))
+ CCr[0:3, 0:3] = Cr
+ CCr[3, 3] = 1.
+
+ B = np.array(np.dot(CCr, np.dot(A, np.linalg.inv(CC))))
+ B[:, 2] = B[:, 2] - B[:, 3]
+ B = B[0:3, 0:3]
+ B = B / B[2, 2]
return np.array(B)
diff --git a/micasense/imageset.py b/micasense/imageset.py
index df720626..035c2bd2 100644
--- a/micasense/imageset.py
+++ b/micasense/imageset.py
@@ -27,28 +27,32 @@
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-import os, glob, fnmatch
-import micasense.image as image
-import micasense.capture as capture
-from micasense.imageutils import save_capture as save_capture
+import fnmatch
import multiprocessing
+import os
import exiftool
+import micasense.capture as capture
+import micasense.image as image
+from micasense.imageutils import save_capture as save_capture
+
def image_from_file(filename):
return image.Image(filename)
+
class ImageSet(object):
"""
An ImageSet is a container for a group of captures that are processed together
"""
+
def __init__(self, captures):
self.captures = captures
captures.sort()
-
+
@classmethod
- def from_directory(cls, directory, progress_callback=None, exiftool_path=None):
+ def from_directory(cls, directory, progress_callback=None, exiftool_path=None, allow_uncalibrated=False):
"""
Create and ImageSet recursively from the files in a directory
"""
@@ -63,13 +67,13 @@ def from_directory(cls, directory, progress_callback=None, exiftool_path=None):
if exiftool_path is None and os.environ.get('exiftoolpath') is not None:
exiftool_path = os.path.normpath(os.environ.get('exiftoolpath'))
- with exiftool.ExifTool(exiftool_path) as exift:
- for i,path in enumerate(matches):
- images.append(image.Image(path, exiftool_obj=exift))
+ with exiftool.ExifToolHelper(exiftool_path) as exift:
+ for i, path in enumerate(matches):
+ images.append(image.Image(path, exiftool_obj=exift, allow_uncalibrated=allow_uncalibrated))
if progress_callback is not None:
- progress_callback(float(i)/float(len(matches)))
+ progress_callback(float(i) / float(len(matches)))
- # create a dictionary to index the images so we can sort them
+ # create a dictionary to index the images, so we can sort them
# into captures
# {
# "capture_id": [img1, img2, ...]
@@ -89,47 +93,57 @@ def from_directory(cls, directory, progress_callback=None, exiftool_path=None):
if progress_callback is not None:
progress_callback(1.0)
return cls(captures)
-
+
def as_nested_lists(self):
+ """
+ Get timestamp, latitude, longitude, altitude, capture_id, dls-yaw, dls-pitch, dls-roll, and irradiance from all
+ Captures.
+ :return: List data from all Captures, List column headers.
+ """
columns = [
'timestamp',
- 'latitude','longitude','altitude',
+ 'latitude', 'longitude', 'altitude',
'capture_id',
- 'dls-yaw','dls-pitch','dls-roll'
+ 'dls-yaw', 'dls-pitch', 'dls-roll'
]
irr = ["irr-{}".format(wve) for wve in self.captures[0].center_wavelengths()]
columns += irr
- data = []
+ data = []
for cap in self.captures:
dat = cap.utc_time()
loc = list(cap.location())
uuid = cap.uuid
dls_pose = list(cap.dls_pose())
irr = cap.dls_irradiance()
- row = [dat]+loc+[uuid]+dls_pose+irr
+ row = [dat] + loc + [uuid] + dls_pose + irr
data.append(row)
return data, columns
def dls_irradiance(self):
+ """
+ Get utc_time and irradiance for each Capture in ImageSet.
+ :return: dict {utc_time : [irradiance, ...]}
+ """
series = {}
for cap in self.captures:
dat = cap.utc_time().isoformat()
irr = cap.dls_irradiance()
series[dat] = irr
- def save_stacks(self, warp_matrices, stackDirectory, thumbnailDirectory=None, irradiance=None, multiprocess=True, overwrite=False, progress_callback=None):
-
- if not os.path.exists(stackDirectory):
- os.makedirs(stackDirectory)
- if thumbnailDirectory is not None and not os.path.exists(thumbnailDirectory):
- os.makedirs(thumbnailDirectory)
+ def save_stacks(self, warp_matrices, stack_directory, thumbnail_directory=None, irradiance=None, multiprocess=True,
+ overwrite=False, progress_callback=None):
+
+ if not os.path.exists(stack_directory):
+ os.makedirs(stack_directory)
+ if thumbnail_directory is not None and not os.path.exists(thumbnail_directory):
+ os.makedirs(thumbnail_directory)
save_params_list = []
- for capture in self.captures:
+ for local_capture in self.captures:
save_params_list.append({
- 'output_path': stackDirectory,
- 'thumbnail_path': thumbnailDirectory,
- 'file_list': [img.path for img in capture.images],
+ 'output_path': stack_directory,
+ 'thumbnail_path': thumbnail_directory,
+ 'file_list': [img.path for img in local_capture.images],
'warp_matrices': warp_matrices,
'irradiance_list': irradiance,
'photometric': 'MINISBLACK',
@@ -138,12 +152,11 @@ def save_stacks(self, warp_matrices, stackDirectory, thumbnailDirectory=None, ir
if multiprocess:
pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
- for i,_ in enumerate(pool.imap_unordered(save_capture, save_params_list)):
+ for i, _ in enumerate(pool.imap_unordered(save_capture, save_params_list)):
if progress_callback is not None:
- progress_callback(float(i)/float(len(save_params_list)))
+ progress_callback(float(i) / float(len(save_params_list)))
pool.close()
pool.join()
else:
for params in save_params_list:
save_capture(params)
-
diff --git a/micasense/imageutils.py b/micasense/imageutils.py
index c718527c..4f163485 100644
--- a/micasense/imageutils.py
+++ b/micasense/imageutils.py
@@ -23,55 +23,142 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-import cv2
+import multiprocessing
import os
+
+import cv2
+import exiftool
import numpy as np
-import multiprocessing
-from skimage import exposure
+from skimage.filters import gaussian, rank
+from skimage.morphology import binary_closing
from skimage.morphology import disk
-from skimage.filters import rank, gaussian
+from skimage.transform import warp
from skimage.util import img_as_ubyte
-def normalize(im, min=None, max=None):
+
+# start helper functions for finding a "hole"-free rectangle
+def get_longest_sequence(b):
+ if b.any():
+ d = np.diff(np.pad(b, 1))
+ xS = np.where(d > 0)[0]
+ xE = np.where(d < 0)[0]
+ ix = np.argmax(xE - xS)
+ return (xE[ix] - xS[ix]), xS[ix], xE[ix]
+ else:
+ return 0, 0, 0
+
+
+def max_hist_rect(h):
+ if h.sum() > 0:
+ maxArea = 0
+ xS = 0
+ xE = 0
+ vals = np.unique(np.sort(h))[::-1]
+ maxArea = 0
+ for v in vals:
+ b = (h >= v) * 1
+ if b.sum() * v > maxArea:
+ area, xs, xe = get_longest_sequence(b)
+ area *= v
+ if area > maxArea:
+ # print("{:d}: {:d}, {:d}, {:d}".format(v,area,xs,xe))
+ maxArea = area
+ xS = xs
+ xE = xe
+ return maxArea, xS, xE
+ else:
+ return 0, 0, 0
+
+
+def findoptimalrect(overlap, nbands=5):
+ omap = (overlap == nbands) * 1
+ w0 = 0
+ h0 = 0
+ x0 = 0
+ y0 = 0
+ a0 = 0
+ h = np.zeros(omap.shape[1])
+ hS = np.zeros_like(omap)
+ for y, o in enumerate(omap):
+ h += o
+ hS[y] = h
+ area, xS, xE = max_hist_rect(h)
+ if area > a0:
+ a0 = area
+ h0 = h[xS:xE].min()
+ w0 = xE - xS
+ y0 = y - h0
+ x0 = xS
+ ur = (int(x0), int(y0))
+ ll = (int(x0 + w0), int(y0 + h0))
+ return ur, ll
+
+
+def findoptimal_rect_noholes(overlap, nbands=5):
+ omap = (overlap == nbands) * 1
+ b = []
+ e = []
+ w = []
+ for o in omap:
+ ww, bb, ee = get_longest_sequence(o)
+ b.append(bb)
+ e.append(ee)
+ w.append(ww)
+ b = np.array(b)
+ e = np.array(e)
+ w = np.array(w)
+ area, y0, y1 = max_hist_rect(w)
+ x0 = b[y0:y1].max()
+ x1 = e[y0:y1].min()
+ return (x0, y0), (x1, y1)
+
+
+# end helper functions for finding a "hole"-free rectangle
+def normalize(im, local_min=None, local_max=None):
width, height = im.shape
norm = np.zeros((width, height), dtype=np.float32)
- if min is not None and max is not None:
- norm = (im - min) / (max-min)
+ if local_min is not None and local_max is not None:
+ norm = (im - local_min) / (local_max - local_min)
else:
cv2.normalize(im, dst=norm, alpha=0.0, beta=1.0, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)
- norm[norm<0.0] = 0.0
- norm[norm>1.0] = 1.0
+ norm[norm < 0.0] = 0.0
+ norm[norm > 1.0] = 1.0
return norm
+
def local_normalize(im):
- norm = img_as_ubyte(normalize(im)) # TODO: mainly using this as a type conversion, but it's expensive
+ norm = img_as_ubyte(normalize(im)) # TODO: mainly using this as a type conversion, but it's expensive
width, _ = im.shape
- disksize = int(width/5)
+ disksize = int(width / 5)
if disksize % 2 == 0:
disksize = disksize + 1
- selem = disk(disksize)
- norm2 = rank.equalize(norm, selem=selem)
+ footprint = disk(disksize)
+ norm2 = rank.equalize(norm, footprint=footprint)
return norm2
+
def gradient(im, ksize=5):
im = local_normalize(im)
# im = normalize(im)
- grad_x = cv2.Sobel(im,cv2.CV_32F,1,0,ksize=ksize)
- grad_y = cv2.Sobel(im,cv2.CV_32F,0,1,ksize=ksize)
+ grad_x = cv2.Sobel(im, cv2.CV_32F, 1, 0, ksize=ksize)
+ grad_y = cv2.Sobel(im, cv2.CV_32F, 0, 1, ksize=ksize)
grad = cv2.addWeighted(np.absolute(grad_x), 0.5, np.absolute(grad_y), 0.5, 0)
return grad
+
def relatives_ref_band(capture):
for img in capture.images:
- if img.rig_xy_offset_in_px() == (0,0):
+ if img.rig_xy_offset_in_px() == (0, 0):
return img.band_index()
- return (0)
+ return 0
+
def translation_from_ref(capture, band, ref=4):
- x,y = capture.images[band].rig_xy_offset_in_px()
- rx,ry = capture.images[ref].rig_xy_offset_in_px()
+ x, y = capture.images[band].rig_xy_offset_in_px()
+ rx, ry = capture.images[ref].rig_xy_offset_in_px()
return
+
def align(pair):
""" Determine an alignment matrix between two images
@input:
@@ -109,20 +196,20 @@ def align(pair):
warp_matrix = pair['warp_matrix_init']
else:
# warp_matrix = np.array([[1,0,0],[0,1,0]], dtype=np.float32)
- warp_matrix = np.array([[1,0,translations[1]],[0,1,translations[0]]], dtype=np.float32)
+ warp_matrix = np.array([[1, 0, translations[1]], [0, 1, translations[0]]], dtype=np.float32)
w = pair['ref_image'].shape[1]
if pair['pyramid_levels'] is None:
- nol = int(w / (1280/3)) - 1
+ nol = int(w / (1280 / 3)) - 1
else:
nol = pair['pyramid_levels']
if pair['debug']:
- print("number of pyramid levels: {}".format(nol))
+ print(("number of pyramid levels: {}".format(nol)))
- warp_matrix[0][2] /= (2**nol)
- warp_matrix[1][2] /= (2**nol)
+ warp_matrix[0][2] /= (2 ** nol)
+ warp_matrix[1][2] /= (2 ** nol)
if ref_index != match_index:
@@ -131,23 +218,23 @@ def align(pair):
gray1 = pair['ref_image']
gray2 = pair['match_image']
if gray2.shape[0] < gray1.shape[0]:
- cv2.resize(gray2, None, fx=gray1.shape[0]/gray2.shape[0], fy=gray1.shape[0]/gray2.shape[0],
- interpolation=cv2.INTER_AREA)
+ cv2.resize(gray2, None, fx=gray1.shape[0] / gray2.shape[0], fy=gray1.shape[0] / gray2.shape[0],
+ interpolation=cv2.INTER_AREA)
gray1_pyr = [gray1]
gray2_pyr = [gray2]
for level in range(nol):
gray1_pyr[0] = gaussian(normalize(gray1_pyr[0]))
- gray1_pyr.insert(0, cv2.resize(gray1_pyr[0], None, fx=1/2, fy=1/2,
- interpolation=cv2.INTER_AREA))
+ gray1_pyr.insert(0, cv2.resize(gray1_pyr[0], None, fx=1 / 2, fy=1 / 2,
+ interpolation=cv2.INTER_AREA))
gray2_pyr[0] = gaussian(normalize(gray2_pyr[0]))
- gray2_pyr.insert(0, cv2.resize(gray2_pyr[0], None, fx=1/2, fy=1/2,
- interpolation=cv2.INTER_AREA))
+ gray2_pyr.insert(0, cv2.resize(gray2_pyr[0], None, fx=1 / 2, fy=1 / 2,
+ interpolation=cv2.INTER_AREA))
# Terminate the optimizer if either the max iterations or the threshold are reached
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, max_iterations, epsilon_threshold)
# run pyramid ECC
- for level in range(nol+1):
+ for level in range(nol + 1):
grad1 = gradient(gray1_pyr[level])
grad2 = gradient(gray2_pyr[level])
@@ -157,82 +244,89 @@ def align(pair):
plotutils.plotwithcolorbar(gray2_pyr[level], "match level {}".format(level))
plotutils.plotwithcolorbar(grad1, "ref grad level {}".format(level))
plotutils.plotwithcolorbar(grad2, "match grad level {}".format(level))
- print("Starting warp for level {} is:\n {}".format(level,warp_matrix))
+ print(("Starting warp for level {} is:\n {}".format(level, warp_matrix)))
try:
- cc, warp_matrix = cv2.findTransformECC(grad1, grad2, warp_matrix, warp_mode, criteria, inputMask=None, gaussFiltSize=1)
+ cc, warp_matrix = cv2.findTransformECC(grad1, grad2, warp_matrix, warp_mode, criteria, inputMask=None,
+ gaussFiltSize=1)
except TypeError:
cc, warp_matrix = cv2.findTransformECC(grad1, grad2, warp_matrix, warp_mode, criteria)
-
+
if show_debug_images:
- print("Warp after alignment level {} is \n{}".format(level,warp_matrix))
+ print(("Warp after alignment level {} is \n{}".format(level, warp_matrix)))
if level != nol: # scale up only the offset by a factor of 2 for the next (larger image) pyramid level
if warp_mode == cv2.MOTION_HOMOGRAPHY:
- warp_matrix = warp_matrix * np.array([[1,1,2],[1,1,2],[0.5,0.5,1]], dtype=np.float32)
+ warp_matrix = warp_matrix * np.array([[1, 1, 2], [1, 1, 2], [0.5, 0.5, 1]], dtype=np.float32)
else:
- warp_matrix = warp_matrix * np.array([[1,1,2],[1,1,2]], dtype=np.float32)
-
-
+ warp_matrix = warp_matrix * np.array([[1, 1, 2], [1, 1, 2]], dtype=np.float32)
return {'ref_index': pair['ref_index'],
'match_index': pair['match_index'],
- 'warp_matrix': warp_matrix }
+ 'warp_matrix': warp_matrix}
+
def default_warp_matrix(warp_mode):
if warp_mode == cv2.MOTION_HOMOGRAPHY:
- return np.array([[1,0,0],[0,1,0],[0,0,1]], dtype=np.float32)
+ return np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.float32)
else:
- return np.array([[1,0,0],[0,1,0]], dtype=np.float32)
+ return np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float32)
-def align_capture(capture, ref_index=1, warp_mode=cv2.MOTION_HOMOGRAPHY, max_iterations=2500, epsilon_threshold=1e-9, multithreaded=True, debug=False, pyramid_levels = None):
- '''Align images in a capture using openCV
+
+def align_capture(capture, ref_index=None, warp_mode=cv2.MOTION_HOMOGRAPHY, max_iterations=2500, epsilon_threshold=1e-9,
+ multithreaded=True, debug=False, pyramid_levels=None):
+ """Align images in a capture using openCV
MOTION_TRANSLATION sets a translational motion model; warpMatrix is 2x3 with the first 2x2 part being the unity matrix and the rest two parameters being estimated.
MOTION_EUCLIDEAN sets a Euclidean (rigid) transformation as motion model; three parameters are estimated; warpMatrix is 2x3.
MOTION_AFFINE sets an affine motion model (DEFAULT); six parameters are estimated; warpMatrix is 2x3.
MOTION_HOMOGRAPHY sets a homography as a motion model; eight parameters are estimated;`warpMatrix` is 3x3.
best results will be AFFINE and HOMOGRAPHY, at the expense of speed
- '''
+ """
+ if ref_index is None:
+ if capture.camera_model == 'Altum' or capture.camera_model == 'RedEdge-M' or capture.camera_model == 'RedEdge':
+ ref_index = 1
+ if capture.camera_model == 'RedEdge-P' or capture.camera_model == 'Altum-PT':
+ ref_index = 5
# Match other bands to this reference image (index into capture.images[])
ref_img = capture.images[ref_index].undistorted(capture.images[ref_index].radiance()).astype('float32')
-
+
if capture.has_rig_relatives():
warp_matrices_init = capture.get_warp_matrices(ref_index=ref_index)
else:
- warp_matrices_init = [default_warp_matrix(warp_mode)]*len(capture.images)
-
+ warp_matrices_init = [default_warp_matrix(warp_mode)] * len(capture.images)
+
alignment_pairs = []
- for i,img in enumerate(capture.images):
+ for i, img in enumerate(capture.images):
if img.rig_relatives is not None:
translations = img.rig_xy_offset_in_px()
else:
- translations = (0,0)
+ translations = (0, 0)
if img.band_name != 'LWIR':
alignment_pairs.append({'warp_mode': warp_mode,
'max_iterations': max_iterations,
'epsilon_threshold': epsilon_threshold,
- 'ref_index':ref_index,
+ 'ref_index': ref_index,
'ref_image': ref_img,
- 'match_index':img.band_index,
- 'match_image':img.undistorted(img.radiance()).astype('float32'),
+ 'match_index': img.band_index,
+ 'match_image': img.undistorted(img.radiance()).astype('float32'),
'translations': translations,
'warp_matrix_init': np.array(warp_matrices_init[i], dtype=np.float32),
'debug': debug,
'pyramid_levels': pyramid_levels})
- warp_matrices = [None]*len(alignment_pairs)
+ warp_matrices = [None] * len(alignment_pairs)
- #required to work across linux/mac/windows, see https://stackoverflow.com/questions/47852237
+ # required to work across linux/mac/windows, see https://stackoverflow.com/questions/47852237
if multithreaded and multiprocessing.get_start_method() != 'spawn':
try:
- multiprocessing.set_start_method('spawn',force=True)
+ multiprocessing.set_start_method('spawn', force=True)
except ValueError:
multithreaded = False
- if(multithreaded):
+ if multithreaded:
pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
- for _,mat in enumerate(pool.imap_unordered(align, alignment_pairs)):
+ for _, mat in enumerate(pool.imap_unordered(align, alignment_pairs)):
warp_matrices[mat['match_index']] = mat['warp_matrix']
- print("Finished aligning band {}".format(mat['match_index']))
+ print(("Finished aligning band {}".format(mat['match_index'])))
pool.close()
pool.join()
else:
@@ -240,49 +334,52 @@ def align_capture(capture, ref_index=1, warp_mode=cv2.MOTION_HOMOGRAPHY, max_ite
for pair in alignment_pairs:
mat = align(pair)
warp_matrices[mat['match_index']] = mat['warp_matrix']
- print("Finished aligning band {}".format(mat['match_index']))
+ print(("Finished aligning band {}".format(mat['match_index'])))
if capture.images[-1].band_name == 'LWIR':
img = capture.images[-1]
alignment_pairs.append({'warp_mode': warp_mode,
'max_iterations': max_iterations,
'epsilon_threshold': epsilon_threshold,
- 'ref_index':ref_index,
+ 'ref_index': ref_index,
'ref_image': ref_img,
- 'match_index':img.band_index,
- 'match_image':img.undistorted(img.radiance()).astype('float32'),
+ 'match_index': img.band_index,
+ 'match_image': img.undistorted(img.radiance()).astype('float32'),
'translations': translations,
'debug': debug})
warp_matrices.append(capture.get_warp_matrices(ref_index)[-1])
return warp_matrices, alignment_pairs
-#apply homography to create an aligned stack
-def aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type = 'reflectance',interpolation_mode=cv2.INTER_LANCZOS4):
- width, height = capture.images[0].size()
- im_aligned = np.zeros((height,width,len(warp_matrices)), dtype=np.float32 )
+# apply homography to create an aligned stack
+def aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type='reflectance',
+ interpolation_mode=cv2.INTER_LANCZOS4):
+ width, height = capture.images[match_index].size()
+
+ im_aligned = np.zeros((height, width, len(warp_matrices)), dtype=np.float32)
- for i in range(0,len(warp_matrices)):
+ for i in range(0, len(warp_matrices)):
if img_type == 'reflectance':
img = capture.images[i].undistorted_reflectance()
else:
img = capture.images[i].undistorted_radiance()
if warp_mode != cv2.MOTION_HOMOGRAPHY:
- im_aligned[:,:,i] = cv2.warpAffine(img,
- warp_matrices[i],
- (width,height),
- flags=interpolation_mode + cv2.WARP_INVERSE_MAP)
+ im_aligned[:, :, i] = cv2.warpAffine(img,
+ warp_matrices[i],
+ (width, height),
+ flags=interpolation_mode + cv2.WARP_INVERSE_MAP)
else:
- im_aligned[:,:,i] = cv2.warpPerspective(img,
- warp_matrices[i],
- (width,height),
- flags=interpolation_mode + cv2.WARP_INVERSE_MAP)
+ im_aligned[:, :, i] = cv2.warpPerspective(img,
+ warp_matrices[i],
+ (width, height),
+ flags=interpolation_mode + cv2.WARP_INVERSE_MAP)
(left, top, w, h) = tuple(int(i) for i in cropped_dimensions)
- im_cropped = im_aligned[top:top+h, left:left+w][:]
+ im_cropped = im_aligned[top:top + h, left:left + w][:]
return im_cropped
+
class BoundPoint(object):
def __init__(self, x=0, y=0):
self.x = x
@@ -294,6 +391,7 @@ def __str__(self):
def __repr__(self):
return self.__str__()
+
class Bounds(object):
def __init__(self):
arbitrary_large_value = 100000000
@@ -306,7 +404,8 @@ def __str__(self):
def __repr__(self):
return self.__str__()
-def find_crop_bounds(capture,registration_transforms,warp_mode=cv2.MOTION_HOMOGRAPHY):
+
+def find_crop_bounds(capture, registration_transforms, warp_mode=cv2.MOTION_HOMOGRAPHY, reference_band=0):
"""Compute the crop rectangle to be applied to a set of images after
registration such that no pixel in the resulting stack of images will
include a blank value for any of the bands
@@ -323,34 +422,36 @@ def find_crop_bounds(capture,registration_transforms,warp_mode=cv2.MOTION_HOMOGR
"""
image_sizes = [image.size() for image in capture.images]
lens_distortions = [image.cv2_distortion_coeff() for image in capture.images]
- camera_matrices = [image.cv2_camera_matrix() for image in capture.images]
-
- bounds = [get_inner_rect(s, a, d, c,warp_mode=warp_mode)[0] for s, a, d, c in zip(image_sizes,registration_transforms, lens_distortions, camera_matrices)]
- edges = [get_inner_rect(s, a, d, c,warp_mode=warp_mode)[1] for s, a, d, c in zip(image_sizes,registration_transforms, lens_distortions, camera_matrices)]
- combined_bounds = get_combined_bounds(bounds, image_sizes[0])
+ camera_matrices = [image.cv2_camera_matrix() for image in capture.images]
+ bounds = [get_inner_rect(s, a, d, c, warp_mode=warp_mode)[0] for s, a, d, c in
+ zip(image_sizes, registration_transforms, lens_distortions, camera_matrices)]
+ edges = [get_inner_rect(s, a, d, c, warp_mode=warp_mode)[1] for s, a, d, c in
+ zip(image_sizes, registration_transforms, lens_distortions, camera_matrices)]
+ combined_bounds = get_combined_bounds(bounds, image_sizes[reference_band])
left = np.ceil(combined_bounds.min.x)
top = np.ceil(combined_bounds.min.y)
width = np.floor(combined_bounds.max.x - combined_bounds.min.x)
height = np.floor(combined_bounds.max.y - combined_bounds.min.y)
- return (left, top, width, height),edges
+ return (left, top, width, height), edges
-def get_inner_rect(image_size, affine, distortion_coeffs, camera_matrix,warp_mode=cv2.MOTION_HOMOGRAPHY):
+
+def get_inner_rect(image_size, affine, distortion_coeffs, camera_matrix, warp_mode=cv2.MOTION_HOMOGRAPHY):
w = image_size[0]
h = image_size[1]
- left_edge = np.array([np.ones(h)*0, np.arange(0, h)]).T
- right_edge = np.array([np.ones(h)*(w-1), np.arange(0, h)]).T
- top_edge = np.array([np.arange(0, w), np.ones(w)*0]).T
- bottom_edge = np.array([np.arange(0, w), np.ones(w)*(h-1)]).T
+ left_edge = np.array([np.ones(h) * 0, np.arange(0, h)]).T
+ right_edge = np.array([np.ones(h) * (w - 1), np.arange(0, h)]).T
+ top_edge = np.array([np.arange(0, w), np.ones(w) * 0]).T
+ bottom_edge = np.array([np.arange(0, w), np.ones(w) * (h - 1)]).T
- left_map = map_points(left_edge, image_size, affine, distortion_coeffs, camera_matrix,warp_mode=warp_mode)
+ left_map = map_points(left_edge, image_size, affine, distortion_coeffs, camera_matrix, warp_mode=warp_mode)
left_bounds = min_max(left_map)
- right_map = map_points(right_edge, image_size, affine, distortion_coeffs, camera_matrix,warp_mode=warp_mode)
+ right_map = map_points(right_edge, image_size, affine, distortion_coeffs, camera_matrix, warp_mode=warp_mode)
right_bounds = min_max(right_map)
- top_map = map_points(top_edge, image_size, affine, distortion_coeffs, camera_matrix,warp_mode=warp_mode)
+ top_map = map_points(top_edge, image_size, affine, distortion_coeffs, camera_matrix, warp_mode=warp_mode)
top_bounds = min_max(top_map)
- bottom_map = map_points(bottom_edge, image_size, affine, distortion_coeffs, camera_matrix,warp_mode=warp_mode)
+ bottom_map = map_points(bottom_edge, image_size, affine, distortion_coeffs, camera_matrix, warp_mode=warp_mode)
bottom_bounds = min_max(bottom_map)
bounds = Bounds()
@@ -358,8 +459,9 @@ def get_inner_rect(image_size, affine, distortion_coeffs, camera_matrix,warp_mod
bounds.max.y = bottom_bounds.min.y
bounds.min.x = left_bounds.max.x
bounds.min.y = top_bounds.max.y
- edges = (left_map,right_map,top_map,bottom_map)
- return bounds,edges
+ edges = (left_map, right_map, top_map, bottom_map)
+ return bounds, edges
+
def get_combined_bounds(bounds, image_size):
w = image_size[0]
@@ -380,8 +482,8 @@ def get_combined_bounds(bounds, image_size):
# limit to image size
final.min.x = max(final.min.x, 0)
final.min.y = max(final.min.y, 0)
- final.max.x = min(final.max.x, w-1)
- final.max.y = min(final.max.y, h-1)
+ final.max.x = min(final.max.x, w - 1)
+ final.max.y = min(final.max.y, h - 1)
# Add 1 px of margin (remove one pixel on all sides)
final.min.x += 1
final.min.y += 1
@@ -390,6 +492,7 @@ def get_combined_bounds(bounds, image_size):
return final
+
def min_max(pts):
bounds = Bounds()
for p in pts:
@@ -403,36 +506,196 @@ def min_max(pts):
bounds.min.y = p[1]
return bounds
-def map_points(pts, image_size, warpMatrix, distortion_coeffs, camera_matrix,warp_mode=cv2.MOTION_HOMOGRAPHY):
+
+def map_points(pts, image_size, warpMatrix, distortion_coeffs, camera_matrix, warp_mode=cv2.MOTION_HOMOGRAPHY):
# extra dimension makes opencv happy
- pts = np.array([pts], dtype=np.float)
+ pts = np.array([pts], dtype=float)
new_cam_mat, _ = cv2.getOptimalNewCameraMatrix(camera_matrix, distortion_coeffs, image_size, 1)
new_pts = cv2.undistortPoints(pts, camera_matrix, distortion_coeffs, P=new_cam_mat)
if warp_mode == cv2.MOTION_AFFINE:
new_pts = cv2.transform(new_pts, cv2.invertAffineTransform(warpMatrix))
if warp_mode == cv2.MOTION_HOMOGRAPHY:
- new_pts =cv2.perspectiveTransform(new_pts,np.linalg.inv(warpMatrix).astype(np.float32))
- #apparently the output order has changed in 4.1.1 (possibly earlier from 3.4.3)
- if cv2.__version__<='3.4.4':
+ new_pts = cv2.perspectiveTransform(new_pts, np.linalg.inv(warpMatrix).astype(np.float32))
+ # apparently the output order has changed in 4.1.1 (possibly earlier from 3.4.3)
+ if cv2.__version__ <= '3.4.4':
return new_pts[0]
else:
- return new_pts[:,0,:]
+ return new_pts[:, 0, :]
+
def save_capture(params):
import micasense.capture as capture
cap = capture.Capture.from_filelist(params['file_list'])
- outputFilename = cap.uuid+'.tif'
- if(os.path.exists(outputFilename) and params['overwrite_existing']==False):
- return outputFilename
+ output_filename = cap.uuid + '.tif'
+ if os.path.exists(output_filename) and not params['overwrite_existing']:
+ return output_filename
- fullOutputPath = os.path.join(params['output_path'], outputFilename)
+ full_output_path = os.path.join(params['output_path'], output_filename)
cap.create_aligned_capture(irradiance_list=params['irradiance_list'], warp_matrices=params['warp_matrices'])
- cap.save_capture_as_stack(fullOutputPath, sort_by_wavelength=True, photometric=params['photometric'])
+ cap.save_capture_as_stack(full_output_path, sort_by_wavelength=True, photometric=params['photometric'])
if params['thumbnail_path'] is not None:
thumbnailFilename = cap.uuid
- fullThumbnailPath= os.path.join(params['thumbnail_path'], thumbnailFilename)
- rgb_band_indices = [cap.band_names_lower().index('red'),cap.band_names_lower().index('green'),cap.band_names_lower().index('blue')]
- cap.save_capture_as_rgb(fullThumbnailPath+'_rgb.jpg', rgb_band_indices = rgb_band_indices, gamma=1.8) # original indices, not sorted
-
- return outputFilename
+ fullThumbnailPath = os.path.join(params['thumbnail_path'], thumbnailFilename)
+ rgb_band_indices = [cap.band_names_lower().index('red'), cap.band_names_lower().index('green'),
+ cap.band_names_lower().index('blue')]
+ cap.save_capture_as_rgb(fullThumbnailPath + '_rgb.jpg', rgb_band_indices=rgb_band_indices,
+ gamma=1.8) # original indices, not sorted
+
+ return output_filename
+
+
+def brovey_pan_sharpen(thecapture, weights=None):
+ # https://desktop.arcgis.com/en/arcmap/10.3/manage-data/raster-and-images/fundamentals-of-panchromatic-sharpening.htm
+
+ # note that this algorithm is the simplest possible pansharpening algorithm and NOT radiometrically correct
+
+ if weights is None:
+ weights = [0.0725, 0.0745, 0.353, 0.070, 0.0296]
+ cam_model = thecapture.camera_model
+ if cam_model not in ('RedEdge-P', 'Altum-PT'):
+ raise Exception("Pan-sharpening only works with RedEdge-P and Altum-PT")
+ blue = input_stack[:, :, 0]
+ green = input_stack[:, :, 1]
+ red = input_stack[:, :, 2]
+ rededge = input_stack[:, :, 4]
+ nir = input_stack[:, :, 3]
+ panchro = input_stack[:, :, 5]
+ output_band_count = input_stack.shape[2] - 1
+ output_stack = np.zeros((input_stack.shape[0], input_stack.shape[1], output_band_count), dtype=np.float32)
+ spectral_weight = np.zeros_like(panchro)
+ for band in range(0, 5):
+ spectral_weight += input_stack[:, :, band] * weights[band]
+ # avoid division by zero for some pixels
+ spectral_weight[spectral_weight < 1e-9] = 1.
+
+ PW = input_stack[:, :, 5] / spectral_weight
+ for band in range(0, 5):
+ output_stack[:, :, band] = input_stack[:, :, band] * PW
+ if cam_model == 'Altum-PT':
+ # output_band_count = output_band_count
+ output_stack[:, :, 5] = input_stack[:, :, 6]
+ return output_stack
+ else:
+ raise Exception("Pan-sharpening only works with RedEdge-P and Altum-PT")
+
+
+def radiometric_pan_sharpen(capture, warp_matrices=None, panchro_band=5, irradiance_list=None):
+ # this function performs a radiometrically accurate pansharpening on the input capture
+ # if no warp matrices are supplied to align the multispec images to the pan band
+ # the camera calibration is used (which produces reasonably well aligned imagers in most cases)
+ # in addition to the pan sharpened stack, the equivalent upsampled stack is also produced
+ # for comparison
+ # use the warp matrices we have for the stack, if not user supplied
+ if warp_matrices is None:
+ print("No SIFT warp matrices provided.")
+ warp_matrices = capture.get_warp_matrices(ref_index=panchro_band)
+ h, w = capture.images[panchro_band].raw().shape
+ if irradiance_list is None:
+ pan = capture.images[panchro_band].undistorted_radiance()
+ else:
+ capture.compute_undistorted_reflectance(irradiance_list=irradiance_list)
+ pan = capture.images[panchro_band].undistorted_reflectance()
+
+ # we need this , because the panchro band doesn't necessarily fully cover the multispec bands
+ pan_mask = binary_closing(pan > 1e-4)
+ if 'LWIR' in capture.band_names():
+ sigma = 12 / 3008 * h
+ panf = gaussian(pan, sigma)
+ pan[pan < 1e-4] = 1.0
+ pansharpened_stack = []
+ upsampled_stack = []
+ overlap = np.zeros_like(pan)
+ for i, wm in zip(capture.images, warp_matrices):
+ if irradiance_list is None:
+ img = i.undistorted_radiance()
+ else:
+ img = i.undistorted_reflectance()
+ hLow, wLow = img.shape
+ if i.band_index != panchro_band:
+ if i.band_name == 'LWIR':
+ pLow = warp(panf, np.linalg.inv(wm), output_shape=(hLow, wLow), preserve_range=True)
+ else:
+ pLow = warp(pan, np.linalg.inv(wm), output_shape=(hLow, wLow), preserve_range=True)
+ panMaskLow = warp(pan_mask, np.linalg.inv(wm), output_shape=(hLow, wLow))
+ pLow[pLow <= 1e-4] = 1.0
+ if irradiance_list is None:
+ mask = binary_closing(i.undistorted_radiance() > 1e-4)
+ r = i.undistorted_radiance() / pLow
+ else:
+ mask = binary_closing(i.undistorted_reflectance() > 1e-4)
+ r = i.undistorted_reflectance() / pLow
+ if i.band_name == 'LWIR':
+ H = warp(r, wm, output_shape=(h, w)) * panf
+ else:
+ H = warp(r, wm, output_shape=(h, w)) * pan
+ if irradiance_list is None:
+ U = warp(i.undistorted_radiance(), wm, output_shape=(h, w), preserve_range=True)
+ else:
+ U = warp(i.undistorted_reflectance(), wm, output_shape=(h, w), preserve_range=True)
+ overlap += warp(mask * panMaskLow, wm, output_shape=(h, w))
+ pansharpened_stack.append(H)
+ upsampled_stack.append(U)
+ else:
+ overlap += (pan_mask > 0)
+ pansharpened_stack.append(pan)
+ upsampled_stack.append(pan)
+
+ N = len(capture.images)
+ (x0, y0), (x1, y1) = findoptimal_rect_noholes(overlap, nbands=N)
+ pansharpened_stack = np.moveaxis(np.array(pansharpened_stack), 0, 2)[y0 + 1:y1 - 1, x0 + 1:x1 - 1, :]
+ upsampled_stack = np.moveaxis(np.array(upsampled_stack), 0, 2)[y0 + 1:y1 - 1, x0 + 1:x1 - 1, :]
+
+ return pansharpened_stack, upsampled_stack
+
+
+# if writing exif for multiple capture sets, it is faster to do it all at the end of the
+# tiff creation instead of writing the exif data as each tiff is created
+def prepare_exif_for_stacks(thecapture, thefilename):
+ lat, lon, alt = thecapture.location()
+ resolution = thecapture.images[0].focal_plane_resolution_px_per_mm
+ # eventually it would be nice to add the capture ID, flight ID,
+ # and yaw/pitch/roll, but these are non-standard exif tags,
+ # so it is more difficult.
+ attitude = thecapture.dls_pose()
+ theid = thecapture.uuid
+ flightid = thecapture.flightid
+ focallength = thecapture.focal_length()
+ latdir = 'N'
+ if lat < 0:
+ latdir = 'S'
+ londir = 'E'
+ if lon < 0:
+ londir = 'W'
+ exif_data = [{"Capture ID": theid}, {"Filename": thefilename}, {"Model": str(thecapture.camera_model)},
+ {"GPSDateStamp": thecapture.utc_time().strftime("%Y:%m:%d")},
+ {"GPSTimeStamp": thecapture.utc_time().strftime("%H:%M:%S.%f")}, {"GPSLatitude": str(lat)},
+ {"GpsLatitudeRef": latdir}, {"GPSLongitude": str(lon)}, {"GPSLongitudeRef": londir},
+ {"GPSAltitude": str(alt) + " m Above Sea Level"}, {"GPSAltitudeRef": "0"},
+ {"FocalLength": str(focallength)}, {"XResolution": str(resolution[0])},
+ {"YResolution": str(resolution[1])}, {"ResolutionUnits": "mm"}]
+ return exif_data
+
+
+def write_exif_to_stack(thecapture=None, thefilename=None, existing_exif_list=None):
+ # without the overwrite_original flag, twice as many stacks will be created
+ overwrite = str.encode("-overwrite_original")
+ if thecapture and thefilename:
+ exif_data = prepare_exif_for_stacks(thecapture, thefilename)
+ elif existing_exif_list:
+ exif_data = existing_exif_list
+ else:
+ raise Exception(
+ "Please provide an existing capture object and filename or a list of existing exif data for batch processing")
+ exif_bytes_list = []
+ for exif in exif_data:
+ for key, val in exif.items():
+ if key != 'Capture ID' and key != 'Filename':
+ new_value = str.encode("-" + key + "=" + val)
+ exif_bytes_list.append(new_value)
+ if key == 'Filename':
+ thefilename = val
+ thefilename = str.encode(thefilename)
+
+ with exiftool.ExifTool() as et:
+ et.execute(*exif_bytes_list, overwrite, thefilename)
diff --git a/micasense/metadata.py b/micasense/metadata.py
index 9a40b1a6..9aa7ffb1 100644
--- a/micasense/metadata.py
+++ b/micasense/metadata.py
@@ -25,50 +25,53 @@
# Support strings in Python 2 and 3
from __future__ import unicode_literals
-import exiftool
+import math
+import os
from datetime import datetime, timedelta
+
+import exiftool
import pytz
-import os
-import math
+
class Metadata(object):
- ''' Container for Micasense image metadata'''
- def __init__(self, filename, exiftoolPath=None, exiftool_obj=None):
+ """ Container for Micasense image metadata"""
+
+ def __init__(self, filename: str, exiftool_path=None, exiftool_obj=None):
if exiftool_obj is not None:
self.exif = exiftool_obj.get_metadata(filename)
return
- if exiftoolPath is not None:
- self.exiftoolPath = exiftoolPath
+ if exiftool_path is not None:
+ self.exiftoolPath = exiftool_path
elif os.environ.get('exiftoolpath') is not None:
self.exiftoolPath = os.path.normpath(os.environ.get('exiftoolpath'))
else:
self.exiftoolPath = None
if not os.path.isfile(filename):
raise IOError("Input path is not a file")
- with exiftool.ExifTool(self.exiftoolPath) as exift:
+ with exiftool.ExifToolHelper() as exift:
self.exif = exift.get_metadata(filename)
def get_all(self):
- ''' Get all extracted metadata items '''
+ """ Get all extracted metadata items """
return self.exif
def get_item(self, item, index=None):
- ''' Get metadata item by Namespace:Parameter'''
+ """ Get metadata item by Namespace:Parameter"""
val = None
try:
- val = self.exif[item]
+ assert len(self.exif) > 0
+ val = self.exif[0][item]
if index is not None:
try:
if isinstance(val, unicode):
- val = val.encode('ascii','ignore')
+ val = val.encode('ascii', 'ignore')
except NameError:
- #throws on python 3 where unicode is undefined
+ # throws on python 3 where unicode is undefined
pass
- if isinstance(val,str) and len(val.split(',')) > 1:
+ if isinstance(val, str) and len(val.split(',')) > 1:
val = val.split(',')
val = val[index]
except KeyError:
- #print ("Item "+item+" not found")
pass
except IndexError:
print("Item {0} is length {1}, index {2} is outside this range.".format(
@@ -78,15 +81,15 @@ def get_item(self, item, index=None):
return val
def size(self, item):
- '''get the size (length) of a metadata item'''
+ """get the size (length) of a metadata item"""
val = self.get_item(item)
try:
if isinstance(val, unicode):
- val = val.encode('ascii','ignore')
+ val = val.encode('ascii', 'ignore')
except NameError:
- #throws on python 3 where unicode is undefined
+ # throws on python 3 where unicode is undefined
pass
- if isinstance(val,str) and len(val.split(',')) > 1:
+ if isinstance(val, str) and len(val.split(',')) > 1:
val = val.split(',')
if val is not None:
return len(val)
@@ -99,48 +102,50 @@ def print_all(self):
def dls_present(self):
return self.get_item("XMP:Irradiance") is not None \
- or self.get_item("XMP:HorizontalIrradiance") is not None \
- or self.get_item("XMP:DirectIrradiance") is not None
+ or self.get_item("XMP:HorizontalIrradiance") is not None \
+ or self.get_item("XMP:DirectIrradiance") is not None
def supports_radiometric_calibration(self):
- if(self.get_item('XMP:RadiometricCalibration')) is None:
+ if (self.get_item('XMP:RadiometricCalibration')) is None:
return False
return True
def position(self):
- '''get the WGS-84 latitude, longitude tuple as signed decimal degrees'''
+ """get the WGS-84 latitude, longitude tuple as signed decimal degrees"""
lat = self.get_item('EXIF:GPSLatitude')
latref = self.get_item('EXIF:GPSLatitudeRef')
- if latref=='S':
+ if latref == 'S':
lat *= -1.0
lon = self.get_item('EXIF:GPSLongitude')
lonref = self.get_item('EXIF:GPSLongitudeRef')
- if lonref=='W':
+ if lonref == 'W':
lon *= -1.0
alt = self.get_item('EXIF:GPSAltitude')
return lat, lon, alt
def utc_time(self):
- ''' Get the timezone-aware datetime of the image capture '''
+ """ Get the timezone-aware datetime of the image capture """
str_time = self.get_item('EXIF:DateTimeOriginal')
- utc_time = datetime.strptime(str_time, "%Y:%m:%d %H:%M:%S")
- subsec = int(self.get_item('EXIF:SubSecTime'))
- negative = 1.0
- if subsec < 0:
- negative = -1.0
- subsec *= -1.0
- subsec = float('0.{}'.format(int(subsec)))
- subsec *= negative
- ms = subsec * 1e3
- utc_time += timedelta(milliseconds = ms)
- timezone = pytz.timezone('UTC')
- utc_time = timezone.localize(utc_time)
+ if str_time:
+ utc_time = datetime.strptime(str_time, "%Y:%m:%d %H:%M:%S")
+ subsec = float(f"0.{self.get_item('EXIF:SubSecTime')}")
+ negative = 1.0
+ if subsec < 0:
+ negative = -1.0
+ subsec *= -1.0
+ subsec *= negative
+ ms = subsec * 1e3
+ utc_time += timedelta(milliseconds=ms)
+ timezone = pytz.timezone('UTC')
+ utc_time = timezone.localize(utc_time)
+ else:
+ utc_time = None
return utc_time
def dls_pose(self):
- ''' get DLS pose as local earth-fixed yaw, pitch, roll in radians '''
+ """ get DLS pose as local earth-fixed yaw, pitch, roll in radians """
if self.get_item('XMP:Yaw') is not None:
- yaw = float(self.get_item('XMP:Yaw')) # should be XMP.DLS.Yaw, but exiftool doesn't expose it that way
+ yaw = float(self.get_item('XMP:Yaw')) # should be XMP.DLS.Yaw, but exiftool doesn't expose it that way
pitch = float(self.get_item('XMP:Pitch'))
roll = float(self.get_item('XMP:Roll'))
else:
@@ -154,6 +159,13 @@ def rig_relatives(self):
else:
return None
+ def rig_translations(self):
+ if self.get_item('XMP:RigTranslations') is not None:
+ nelem = self.size('XMP:RigTranslations')
+ return [float(self.get_item('XMP:RigTranslations', i)) for i in range(nelem)]
+ else:
+ return None
+
def capture_id(self):
return self.get_item('XMP:CaptureId')
@@ -166,6 +178,9 @@ def camera_make(self):
def camera_model(self):
return self.get_item('EXIF:Model')
+ def camera_serial(self):
+ return self.get_item('EXIF:SerialNumber')
+
def firmware_version(self):
return self.get_item('EXIF:Software')
@@ -179,12 +194,12 @@ def exposure(self):
exp = self.get_item('EXIF:ExposureTime')
# correct for incorrect exposure in some legacy RedEdge firmware versions
if self.camera_model() != "Altum":
- if math.fabs(exp-(1.0/6329.0)) < 1e-6:
+ if math.fabs(exp - (1.0 / 6329.0)) < 1e-6:
exp = 0.000274
return exp
def gain(self):
- return self.get_item('EXIF:ISOSpeed')/100.0
+ return self.get_item('EXIF:ISOSpeed') / 100.0
def image_size(self):
return self.get_item('EXIF:ImageWidth'), self.get_item('EXIF:ImageHeight')
@@ -207,85 +222,103 @@ def black_level(self):
num = len(black_lvl)
for pixel in black_lvl:
total += float(pixel)
- return total/float(num)
+ return total / float(num)
def dark_pixels(self):
- ''' get the average of the optically covered pixel values
+ """ get the average of the optically covered pixel values
Note: these pixels are raw, and have not been radiometrically
corrected. Use the black_level() method for all
- radiomentric calibrations '''
+ radiomentric calibrations """
dark_pixels = self.get_item('XMP:DarkRowValue')
total = 0.0
num = len(dark_pixels)
for pixel in dark_pixels:
total += float(pixel)
- return total/float(num)
+ return total / float(num)
def bits_per_pixel(self):
- ''' get the number of bits per pixel, which defines the maximum digital number value in the image '''
+ """ get the number of bits per pixel, which defines the maximum digital number value in the image """
return self.get_item('EXIF:BitsPerSample')
def vignette_center(self):
- ''' get the vignette center in X and Y image coordinates'''
+ """ get the vignette center in X and Y image coordinates"""
nelem = self.size('XMP:VignettingCenter')
return [float(self.get_item('XMP:VignettingCenter', i)) for i in range(nelem)]
def vignette_polynomial(self):
- ''' get the radial vignette polynomial in the order it's defined in the metadata'''
+ """ get the radial vignette polynomial in the order it's defined in the metadata"""
nelem = self.size('XMP:VignettingPolynomial')
return [float(self.get_item('XMP:VignettingPolynomial', i)) for i in range(nelem)]
+ def vignette_polynomial2Dexponents(self):
+ """ get exponents of the 2D polynomial """
+ nelem = self.size('XMP:VignettingPolynomial2DName')
+ return [float(self.get_item('XMP:VignettingPolynomial2DName', i)) for i in range(nelem)]
+
+ def vignette_polynomial2D(self):
+ """ get the 2D polynomial coefficients in the order it's defined in the metadata"""
+ nelem = self.size('XMP:VignettingPolynomial2D')
+ return [float(self.get_item('XMP:VignettingPolynomial2D', i)) for i in range(nelem)]
+
def distortion_parameters(self):
nelem = self.size('XMP:PerspectiveDistortion')
return [float(self.get_item('XMP:PerspectiveDistortion', i)) for i in range(nelem)]
def principal_point(self):
- return [float(item) for item in self.get_item('XMP:PrincipalPoint').split(',')]
+ if self.get_item('XMP:PrincipalPoint') is not None:
+ return [float(item) for item in self.get_item('XMP:PrincipalPoint').split(',')]
+ else:
+ return [0, 0]
def focal_plane_resolution_px_per_mm(self):
- fp_x_resolution = float(self.get_item('EXIF:FocalPlaneXResolution'))
- fp_y_resolution = float(self.get_item('EXIF:FocalPlaneYResolution'))
+ if self.get_item('EXIF:FocalPlaneXResolution') is not None:
+ fp_x_resolution = float(self.get_item('EXIF:FocalPlaneXResolution'))
+ fp_y_resolution = float(self.get_item('EXIF:FocalPlaneYResolution'))
+ else:
+ fp_x_resolution, fp_y_resolution = 0, 0
return fp_x_resolution, fp_y_resolution
def focal_length_mm(self):
units = self.get_item('XMP:PerspectiveFocalLengthUnits')
focal_length_mm = 0.0
- if units == 'mm':
- focal_length_mm = float(self.get_item('XMP:PerspectiveFocalLength'))
- else:
- focal_length_px = float(self.get_item('XMP:PerspectiveFocalLength'))
- focal_length_mm = focal_length_px / self.focal_plane_resolution_px_per_mm()[0]
+ if units is not None:
+ if units == 'mm':
+ focal_length_mm = float(self.get_item('XMP:PerspectiveFocalLength'))
+ else:
+ focal_length_px = float(self.get_item('XMP:PerspectiveFocalLength'))
+ focal_length_mm = focal_length_px / self.focal_plane_resolution_px_per_mm()[0]
return focal_length_mm
def focal_length_35_mm_eq(self):
return float(self.get_item('Composite:FocalLength35efl'))
- def __float_or_zero(self, str):
- if str is not None:
- return float(str)
+ @staticmethod
+ def __float_or_zero(val):
+ if val is not None:
+ return float(val)
else:
return 0.0
def irradiance_scale_factor(self):
- ''' Get the calibration scale factor for the irradiance measurements in this image metadata.
+ """ Get the calibration scale factor for the irradiance measurements in this image metadata.
Due to calibration differences between DLS1 and DLS2, we need to account for a scale factor
change in their respective units. This scale factor is pulled from the image metadata, or, if
- the metadata doesn't give us the scale, we assume one based on a known combination of tags'''
+ the metadata doesn't give us the scale, we assume one based on a known combination of tags"""
if self.get_item('XMP:IrradianceScaleToSIUnits') is not None:
- # the metadata contains the scale
+ # the metadata contains the scale
scale_factor = self.__float_or_zero(self.get_item('XMP:IrradianceScaleToSIUnits'))
- elif self.get_item('XMP:HorizontalIrradiance') is not None:
+ elif self.get_item('XMP:HorizontalIrradiance') is not None:
# DLS2 but the metadata is missing the scale, assume 0.01
scale_factor = 0.01
else:
# DLS1, so we use a scale of 1
scale_factor = 1.0
return scale_factor
-
+
def horizontal_irradiance_valid(self):
- ''' Defines if horizontal irradiance tag contains a value that can be trusted
+ """ Defines if horizontal irradiance tag contains a value that can be trusted
some firmware versions had a bug whereby the direct and scattered irradiance were correct,
- but the horizontal irradiance was calculated incorrectly '''
+ but the horizontal irradiance was calculated incorrectly """
if self.get_item('XMP:HorizontalIrradiance') is None:
return False
from packaging import version
@@ -294,69 +327,73 @@ def horizontal_irradiance_valid(self):
good_version = "1.2.3"
elif self.camera_model() == 'RedEdge' or self.camera_model() == 'RedEdge-M':
good_version = "5.1.7"
+ elif self.camera_model() == 'RedEdge-P':
+ return True
+ elif self.camera_model() == 'Altum-PT':
+ return True
else:
raise ValueError("Camera model is required to be RedEdge or Altum, not {} ".format(self.camera_model()))
return version.parse(version_string) >= version.parse(good_version)
def spectral_irradiance(self):
- ''' Raw spectral irradiance measured by an irradiance sensor.
- Calibrated to W/m^2/nm using irradiance_scale_factor, but not corrected for angles '''
- return self.__float_or_zero(self.get_item('XMP:SpectralIrradiance'))*self.irradiance_scale_factor()
+ """ Raw spectral irradiance measured by an irradiance sensor.
+ Calibrated to W/m^2/nm using irradiance_scale_factor, but not corrected for angles """
+ return self.__float_or_zero(self.get_item('XMP:SpectralIrradiance')) * self.irradiance_scale_factor()
def horizontal_irradiance(self):
- ''' Horizontal irradiance at the earth's surface below the DLS on the plane normal to the gravity
- vector at the location (local flat plane spectral irradiance) '''
- return self.__float_or_zero(self.get_item('XMP:HorizontalIrradiance'))*self.irradiance_scale_factor()
+ """ Horizontal irradiance at the earth's surface below the DLS on the plane normal to the gravity
+ vector at the location (local flat plane spectral irradiance) """
+ return self.__float_or_zero(self.get_item('XMP:HorizontalIrradiance')) * self.irradiance_scale_factor()
def scattered_irradiance(self):
- ''' scattered component of the spectral irradiance '''
- return self.__float_or_zero(self.get_item('XMP:ScatteredIrradiance'))*self.irradiance_scale_factor()
+ """ scattered component of the spectral irradiance """
+ return self.__float_or_zero(self.get_item('XMP:ScatteredIrradiance')) * self.irradiance_scale_factor()
def direct_irradiance(self):
- ''' direct component of the spectral irradiance on a ploane normal to the vector towards the sun '''
- return self.__float_or_zero(self.get_item('XMP:DirectIrradiance'))*self.irradiance_scale_factor()
+ """ direct component of the spectral irradiance on a ploane normal to the vector towards the sun """
+ return self.__float_or_zero(self.get_item('XMP:DirectIrradiance')) * self.irradiance_scale_factor()
def solar_azimuth(self):
- ''' solar azimuth at the time of capture, as calculated by the camera system '''
+ """ solar azimuth at the time of capture, as calculated by the camera system """
return self.__float_or_zero(self.get_item('XMP:SolarAzimuth'))
def solar_elevation(self):
- ''' solar elevation at the time of capture, as calculated by the camera system '''
+ """ solar elevation at the time of capture, as calculated by the camera system """
return self.__float_or_zero(self.get_item('XMP:SolarElevation'))
def estimated_direct_vector(self):
- ''' estimated direct light vector relative to the DLS2 reference frame'''
+ """ estimated direct light vector relative to the DLS2 reference frame"""
if self.get_item('XMP:EstimatedDirectLightVector') is not None:
return [self.__float_or_zero(item) for item in self.get_item('XMP:EstimatedDirectLightVector')]
else:
return None
def auto_calibration_image(self):
- ''' True if this image is an auto-calibration image, where the camera has found and idetified
- a calibration panel '''
+ """ True if this image is an auto-calibration image, where the camera has found and identified
+ a calibration panel """
cal_tag = self.get_item('XMP:CalibrationPicture')
return cal_tag is not None and \
- cal_tag == 2 and \
- self.panel_albedo() is not None and \
- self.panel_region() is not None and \
- self.panel_serial() is not None
+ cal_tag == 2 and \
+ self.panel_albedo() is not None and \
+ self.panel_region() is not None and \
+ self.panel_serial() is not None
def panel_albedo(self):
- ''' Surface albedo of the active portion of the reflectance panel as calculated by the camera
- (usually from the informatoin in the panel QR code) '''
+ """ Surface albedo of the active portion of the reflectance panel as calculated by the camera
+ (usually from the information in the panel QR code) """
albedo = self.get_item('XMP:Albedo')
if albedo is not None:
return self.__float_or_zero(albedo)
return albedo
def panel_region(self):
- ''' A 4-tuple containing image x,y coordinates of the panel active area '''
+ """ A 4-tuple containing image x,y coordinates of the panel active area """
if self.get_item('XMP:ReflectArea') is not None:
coords = [int(item) for item in self.get_item('XMP:ReflectArea').split(',')]
return list(zip(coords[0::2], coords[1::2]))
else:
return None
-
+
def panel_serial(self):
- ''' The panel serial number as extracted from the image by the camera '''
+ """ The panel serial number as extracted from the image by the camera """
return self.get_item('XMP:PanelSerial')
diff --git a/micasense/panel.py b/micasense/panel.py
index 836fdada..007a2068 100644
--- a/micasense/panel.py
+++ b/micasense/panel.py
@@ -24,18 +24,20 @@
"""
import math
-import numpy as np
-import cv2
import re
-import pyzbar.pyzbar as pyzbar
-from skimage import measure
+import cv2
import matplotlib.pyplot as plt
-import micasense.imageutils as imageutils
+import numpy as np
+import pyzbar.pyzbar as pyzbar
+from skimage import measure
+
class Panel(object):
- def __init__(self, img,panelCorners=None):
+ def __init__(self, img, panel_corners=None, ignore_autocalibration=False):
+ # if we have panel images with QR metadata, panel detection is not called,
+ # so this can be forced here
if img is None:
raise IOError("Must provide an image")
@@ -43,12 +45,12 @@ def __init__(self, img,panelCorners=None):
bias = img.radiance().min()
scale = (img.radiance().max() - bias)
self.gray8b = np.zeros(img.radiance().shape, dtype='uint8')
- cv2.convertScaleAbs(img.undistorted(img.radiance()), self.gray8b, 256.0/scale, -1.0*scale*bias)
-
- if self.image.auto_calibration_image:
- self.__panel_type = "auto" ## panels the camera found we call auto
- if panelCorners is not None:
- self.__panel_bounds = np.array(panelCorners)
+ cv2.convertScaleAbs(img.undistorted(img.radiance()), self.gray8b, 256.0 / scale, -1.0 * scale * bias)
+
+ if self.image.auto_calibration_image and ~ignore_autocalibration:
+ self.__panel_type = "auto" # panels the camera found we call auto
+ if panel_corners is not None:
+ self.__panel_bounds = np.array(panel_corners)
else:
self.__panel_bounds = np.array(self.image.panel_region)
self.panel_albedo = self.image.panel_albedo
@@ -59,9 +61,11 @@ def __init__(self, img,panelCorners=None):
self.saturated_panel_pixels_pct = None
self.panel_pixels_mean = None
self.panel_version = None
-
+ if re.search(r'RP\d{2}-(\d{7})-\D{2}', self.image.panel_serial):
+ self.serial = self.image.panel_serial
+ self.panel_version = int(self.image.panel_serial[2:4])
else:
- self.__panel_type = "search" ## panels we search for we call search
+ self.__panel_type = "search" # panels we search for we call search
self.serial = None
self.qr_area = None
self.qr_bounds = None
@@ -69,8 +73,8 @@ def __init__(self, img,panelCorners=None):
self.saturated_panel_pixels_pct = None
self.panel_pixels_mean = None
self.panel_version = None
- if panelCorners is not None:
- self.__panel_bounds = np.array(panelCorners)
+ if panel_corners is not None:
+ self.__panel_bounds = np.array(panel_corners)
else:
self.__panel_bounds = None
@@ -87,11 +91,9 @@ def __find_qr(self):
self.panel_version = int(self.serial[2:4])
self.qr_bounds = []
for point in symbol.polygon:
- self.qr_bounds.append([point.x,point.y])
+ self.qr_bounds.append([point.x, point.y])
self.qr_bounds = np.asarray(self.qr_bounds, np.int32)
self.qr_area = cv2.contourArea(self.qr_bounds)
- # print (symbol.polygon)
- # print (self.qr_bounds)
break
def __pt_in_image_bounds(self, pt):
@@ -101,132 +103,177 @@ def __pt_in_image_bounds(self, pt):
if pt[1] >= height or pt[1] < 0:
return False
return True
-
+
def reflectance_from_panel_serial(self):
if self.__panel_type == 'auto':
return self.panel_albedo
-
+
if self.serial is None:
self.__find_qr()
if self.serial is None:
raise ValueError("Panel serial number not found")
if self.panel_version >= 4:
min_wl = float(self.serial[-14:-10])
- min_rf = float(self.serial[-10:-7])/1000.0
+ min_rf = float(self.serial[-10:-7]) / 1000.0
max_wl = float(self.serial[-7:-3])
- max_rf = float(self.serial[-3:])/1000.0
- c = np.polyfit([min_wl,max_wl], [min_rf,max_rf], 1)
+ max_rf = float(self.serial[-3:]) / 1000.0
+ c = np.polyfit([min_wl, max_wl], [min_rf, max_rf], 1)
p = np.poly1d(c)
return p(self.image.center_wavelength)
else:
return None
+ def get_panel_type(self):
+ print(self.__panel_type)
+
def qr_corners(self):
if self.__panel_type == 'auto':
return None
-
+
if self.qr_bounds is None:
self.__find_qr()
return self.qr_bounds
def panel_detected(self):
- if self.__expect_panel() == False:
+ if not self.__expect_panel():
return False
-
+
if self.__panel_type == 'auto':
return True
-
+
if self.serial is None:
self.__find_qr()
return self.qr_bounds is not None
def panel_corners(self):
""" get the corners of a panel region based on the qr code location
- Our algorithm to do this uses a 'reference' qr code location and
+ Our algorithm to do this uses a 'reference' qr code location, and
it's associate panel region. We find the affine transform
between the reference qr and our qr, and apply that same transform to the
reference panel region to find our panel region. Because of a limitation
of the pyzbar library, the rotation of the absolute QR code isn't known,
so we then try all 4 rotations and test against a cost function which is the
- minimum of the standard devation divided by the mean value for the panel region"""
+ minimum of the standard deviation divided by the mean value for the panel region"""
if self.__panel_bounds is not None:
return self.__panel_bounds
if self.serial is None:
self.__find_qr()
- if self.serial is None: # didn't find a panel in this image
+ if self.serial is None: # didn't find a panel in this image
return None
-
+
if self.panel_version < 3:
- reference_panel_pts = np.asarray([[894, 469], [868, 232], [630, 258], [656, 496]],
- dtype=np.int32)
- reference_qr_pts = np.asarray([[898, 748], [880, 567], [701, 584], [718, 762]],
- dtype=np.int32)
- elif self.panel_version >= 3:
- reference_panel_pts = np.asarray([[557, 350], [550, 480], [695, 480], [700, 350]], dtype=np.int32)
- reference_qr_pts = np.asarray([[821, 324], [819, 506], [996, 509], [999, 330]], dtype=np.int32)
+ # use the actual panel measures here - we use units of [mm]
+ # the panel is 154.4 x 152.4 mm , vs. the 84 x 84 mm for the QR code
+ # it is left 143.20 mm from the QR code
+ # use the inner 50% square of the panel
+ s = 76.2
+ p = 42
+ T = np.array([-143.2, 0])
+
+ elif (self.panel_version >= 3) and (self.panel_version < 6):
+ s = 50
+ p = 45
+ T = np.array([-145.8, 0])
+ elif self.panel_version >= 6:
+ # use the actual panel measures here - we use units of [mm]
+ # the panel is 100 x 100 mm , vs. the 91 x 91 mm for the QR code
+ # it is down 125.94 mm from the QR code
+ # use the inner 50% square of the panel
+ p = 41
+ s = 50
+ T = np.array([0, -130.84])
+ reference_panel_pts = np.asarray([[-s, s], [s, s], [s, -s], [-s, -s]], dtype=np.float32) * .5 + T
+ reference_qr_pts = np.asarray([[-p, p], [p, p], [p, -p], [-p, -p]], dtype=np.float32)
bounds = []
costs = []
- for rotation in range(0,4):
+ for rotation in range(0, 4):
qr_points = np.roll(reference_qr_pts, rotation, axis=0)
- src = np.asarray([tuple(row) for row in qr_points[:3]], np.float32)
- dst = np.asarray([tuple(row) for row in self.qr_corners()[:3]], np.float32)
- warp_matrix = cv2.getAffineTransform(src, dst)
+ src = np.asarray([tuple(row) for row in qr_points[:]], np.float32)
+ dst = np.asarray([tuple(row) for row in self.qr_corners()[:]], np.float32)
+
+ # we determine the homography from the 4 corner points
+ warp_matrix = cv2.getPerspectiveTransform(src, dst)
+
+ pts = np.asarray([reference_panel_pts], 'float32')
+ panel_bounds = cv2.convexHull(cv2.perspectiveTransform(pts, warp_matrix), clockwise=False)
+ panel_bounds = np.squeeze(panel_bounds) # remove nested lists
- pts = np.asarray([reference_panel_pts], 'int32')
- panel_bounds = cv2.convexHull(cv2.transform(pts, warp_matrix), clockwise=False)
- panel_bounds = np.squeeze(panel_bounds) # remove nested lists
-
bounds_in_image = True
for i, point in enumerate(panel_bounds):
if not self.__pt_in_image_bounds(point):
bounds_in_image = False
if bounds_in_image:
- mean, std, _, _ = self.region_stats(self.image.raw(),panel_bounds, sat_threshold=65000)
- bounds.append(panel_bounds)
- costs.append(std/mean)
+ mean, std, _, _ = self.region_stats(self.image.raw(), panel_bounds, sat_threshold=65000)
+ bounds.append(panel_bounds.astype(np.int32))
+ costs.append(std / mean)
idx = costs.index(min(costs))
self.__panel_bounds = bounds[idx]
return self.__panel_bounds
+ def ordered_panel_coordinates(self):
+ """
+ Return panel region coordinates in a predictable order. Panel region coordinates that are automatically
+ detected by the camera are ordered differently than coordinates detected by Panel.panel_corners().
+ :return: [ (ur), (ul), (ll), (lr) ] to mirror Image.panel_region attribute order
+ """
+ pc = self.panel_corners()
+ pc = sorted(pc, key=lambda x: x[0])
+
+ # get the coordinates on the "left" and "right" side of the bounding box
+ left_coords = pc[:2]
+ right_coords = pc[2:]
+
+ # sort y values ascending for correct order
+ left_coords = sorted(left_coords, key=lambda y: y[0])
+ right_coords = sorted(right_coords, key=lambda y: y[0])
+
+ return [tuple(right_coords[1]), tuple(left_coords[1]), tuple(left_coords[0]), tuple(right_coords[0])]
+
def region_stats(self, img, region, sat_threshold=None):
- """Provide regional statistics for a image over a region
+ """Provide regional statistics for an image over a region
Inputs: img is any image ndarray, region is a skimage shape
Outputs: mean, std, count, and saturated count tuple for the region"""
- rev_panel_pts = np.fliplr(region) #skimage and opencv coords are reversed
+ rev_panel_pts = np.fliplr(region) # skimage and opencv coords are reversed
w, h = img.shape
- mask = measure.grid_points_in_poly((w,h),rev_panel_pts)
+ mask = measure.grid_points_in_poly((w, h), rev_panel_pts)
num_pixels = mask.sum()
panel_pixels = img[mask]
stdev = panel_pixels.std()
mean_value = panel_pixels.mean()
saturated_count = 0
if sat_threshold is not None:
- saturated_px = np.asarray(np.where(panel_pixels > sat_threshold))
- saturated_count = saturated_px.sum()
+ saturated_count = (panel_pixels > sat_threshold).sum()
+ # set saturated pixels here
+ if num_pixels > 0:
+ self.saturated_panel_pixels_pct = (100.0 * saturated_count) / num_pixels
return mean_value, stdev, num_pixels, saturated_count
-
+
def raw(self):
raw_img = self.image.undistorted(self.image.raw())
return self.region_stats(raw_img,
self.panel_corners(),
sat_threshold=65000)
+
def intensity(self):
intensity_img = self.image.undistorted(self.image.intensity())
return self.region_stats(intensity_img,
self.panel_corners(),
sat_threshold=65000)
+
def radiance(self):
radiance_img = self.image.undistorted(self.image.radiance())
return self.region_stats(radiance_img,
self.panel_corners())
-
+
def reflectance_mean(self):
reflectance_image = self.image.reflectance()
if reflectance_image is None:
- print("First calculate the reflectance image by providing a\n band specific irradiance to the calling image.reflectance(irradiance)")
+ print(
+ "First calculate the reflectance image by providing a\n band specific irradiance to the calling "
+ "image.reflectance(irradiance)")
mean, _, _, _ = self.region_stats(reflectance_image,
self.panel_corners())
return mean
@@ -236,27 +283,27 @@ def irradiance_mean(self, reflectance):
return radiance_mean * math.pi / reflectance
def plot_image(self):
- display_img = cv2.cvtColor(self.gray8b,cv2.COLOR_GRAY2RGB)
+ display_img = cv2.cvtColor(self.gray8b, cv2.COLOR_GRAY2RGB)
if self.panel_detected():
if self.qr_corners() is not None:
- cv2.drawContours(display_img,[self.qr_corners()], 0, (255, 0, 0), 3)
- cv2.drawContours(display_img,[self.panel_corners()], 0, (0,0, 255), 3)
+ cv2.drawContours(display_img, [self.qr_corners()], 0, (255, 0, 0), 3)
+ cv2.drawContours(display_img, [self.panel_corners()], 0, (0, 0, 255), 3)
font = cv2.FONT_HERSHEY_DUPLEX
if self.panel_detected():
if self.qr_corners() is not None:
- xloc = self.qr_corners()[0][0]-100
- yloc = self.qr_corners()[0][1]+100
+ xloc = self.qr_corners()[0][0] - 100
+ yloc = self.qr_corners()[0][1] + 100
else:
- xloc = self.panel_corners()[0][0]-100
- yloc = self.panel_corners()[0][1]+100
- cv2.putText(display_img, str(self.serial).split('_')[0], (xloc,yloc), font, 1, 255, 2)
+ xloc = self.panel_corners()[0][0] - 100
+ yloc = self.panel_corners()[0][1] + 100
+ cv2.putText(display_img, str(self.serial).split('_')[0], (xloc, yloc), font, 1, 255, 2)
return display_img
- def plot(self, figsize=(14,14)):
+ def plot(self, figsize=(14, 14)):
display_img = self.plot_image()
fig, ax = plt.subplots(figsize=figsize)
ax.imshow(display_img)
plt.tight_layout()
plt.show()
- return fig, ax
\ No newline at end of file
+ return fig, ax
diff --git a/micasense/plotutils.py b/micasense/plotutils.py
index 6b93c33e..62994e6b 100644
--- a/micasense/plotutils.py
+++ b/micasense/plotutils.py
@@ -24,12 +24,12 @@
"""
import matplotlib.pyplot as plt
-from mpl_toolkits.axes_grid1 import make_axes_locatable
-from mpl_toolkits.mplot3d import Axes3D
from matplotlib.pylab import cm
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
def plotwithcolorbar(img, title=None, figsize=None, vmin=None, vmax=None):
- ''' Plot an image with a colorbar '''
+ """ Plot an image with a colorbar """
fig, axis = plt.subplots(1, 1, figsize=figsize)
rad2 = axis.imshow(img, vmin=vmin, vmax=vmax)
axis.set_title(title)
@@ -40,12 +40,13 @@ def plotwithcolorbar(img, title=None, figsize=None, vmin=None, vmax=None):
plt.show()
return fig, axis
+
def subplotwithcolorbar(rows, cols, images, titles=None, figsize=None):
- ''' Plot a set of images in subplots '''
- fig, axes = plt.subplots(rows, cols, figsize=figsize,squeeze=False)
- for i in range(cols*rows):
- column = int(i%cols)
- row = int(i/cols)
+ """ Plot a set of images in subplots """
+ fig, axes = plt.subplots(rows, cols, figsize=figsize, squeeze=False)
+ for i in range(cols * rows):
+ column = int(i % cols)
+ row = int(i / cols)
if i < len(images):
rad = axes[row][column].imshow(images[i])
if titles is not None:
@@ -59,23 +60,26 @@ def subplotwithcolorbar(rows, cols, images, titles=None, figsize=None):
plt.show()
return fig, axes
-def plot_overlay_withcolorbar(imgbase, imgcolor, title=None, figsize=None, vmin=None, vmax=None, overlay_alpha=1.0, overlay_colormap='viridis', overlay_steps=None, display_contours=False, contour_fmt=None, contour_steps=None, contour_alpha=None, show=True):
- ''' Plot an image with a colorbar '''
+
+def plot_overlay_withcolorbar(imgbase, imgcolor, title=None, figsize=None, vmin=None, vmax=None, overlay_alpha=1.0,
+ overlay_colormap='viridis', overlay_steps=None, display_contours=False, contour_fmt=None,
+ contour_steps=None, contour_alpha=None, show=True):
+ """ Plot an image with a colorbar """
fig, axis = plt.subplots(1, 1, figsize=figsize, squeeze=False)
base = axis[0][0].imshow(imgbase)
if overlay_steps is not None:
- overlay_colormap = cm.get_cmap(overlay_colormap,overlay_steps)
+ overlay_colormap = cm.get_cmap(overlay_colormap, overlay_steps)
rad2 = axis[0][0].imshow(imgcolor, vmin=vmin, vmax=vmax, alpha=overlay_alpha, cmap=overlay_colormap)
if display_contours:
if contour_steps is None:
contour_steps = overlay_steps
if contour_alpha is None:
contour_alpha = overlay_alpha
- contour_cmap = cm.get_cmap(overlay_colormap,contour_steps)
- contour_list = np.arange(vmin, vmax, (vmax-vmin)/contour_steps)
+ contour_cmap = cm.get_cmap(overlay_colormap, contour_steps)
+ contour_list = np.arange(vmin, vmax, (vmax - vmin) / contour_steps)
rad3 = axis[0][0].contour(imgcolor, contour_list, cmap=contour_cmap, alpha=contour_alpha)
- fontsize=8+(max(figsize)/10)*2
- axis[0][0].clabel(rad3,rad3.levels,inline=True,fontsize=fontsize,fmt=contour_fmt)
+ fontsize = 8 + (max(figsize) / 10) * 2
+ axis[0][0].clabel(rad3, rad3.levels, inline=True, fontsize=fontsize, fmt=contour_fmt)
axis[0][0].set_title(title)
divider = make_axes_locatable(axis[0][0])
cax = divider.append_axes("right", size="3%", pad=0.05)
@@ -85,12 +89,13 @@ def plot_overlay_withcolorbar(imgbase, imgcolor, title=None, figsize=None, vmin=
plt.show()
return fig, axis[0][0]
+
def subplot(rows, cols, images, titles=None, figsize=None):
- ''' Plot a set of images in subplots '''
+ """ Plot a set of images in subplots """
fig, axes = plt.subplots(rows, cols, figsize=figsize, squeeze=False)
- for i in range(cols*rows):
- column = int(i%cols)
- row = int(i/cols)
+ for i in range(cols * rows):
+ column = int(i % cols)
+ row = int(i / cols)
if i < len(images):
rad = axes[row][column].imshow(images[i])
if titles is not None:
@@ -101,30 +106,34 @@ def subplot(rows, cols, images, titles=None, figsize=None):
plt.show()
return fig, axes
+
def colormap(cmap):
- ''' Set the defalut plotting colormap
+ """ Set the defalut plotting colormap
Could be one of 'gray, viridis, plasma, inferno, magma, nipy_spectral'
- '''
+ """
plt.set_cmap(cmap)
+
import numpy as np
-def plot_ned_vector3d(x,y,z, u=0,v=0,w=0, title=None, figsize=(8,5)):
- '''Create a 3d plot of a North-East-Down vector. XYZ is the (tip of the) vector,
- uvw is the base location of the vector '''
+
+
+def plot_ned_vector3d(x, y, z, u=0, v=0, w=0, title=None, figsize=(8, 5)):
+ """Create a 3d plot of a North-East-Down vector. XYZ is the (tip of the) vector,
+ uvw is the base location of the vector """
fig = plt.figure(figsize=figsize)
ax = fig.gca(projection='3d')
ax.quiver(u, v, w, x, y, z, color='r')
ax.quiver(u, v, w, x, y, 0, color='b')
ax.quiver(x, y, 0, 0, 0, z, color='g')
-
+
ax.legend()
- ax.set_xlim([-1,1])
- ax.set_ylim([-1,1])
- ax.set_zlim([0,1])
+ ax.set_xlim([-1, 1])
+ ax.set_ylim([-1, 1])
+ ax.set_zlim([0, 1])
ax.set_xlabel("West - East")
ax.set_ylabel("South - North")
if title is not None:
plt.title(title)
plt.tight_layout()
plt.show()
- return fig,ax
\ No newline at end of file
+ return fig, ax
diff --git a/micasense/utils.py b/micasense/utils.py
old mode 100644
new mode 100755
index 93006b8b..a6f83981
--- a/micasense/utils.py
+++ b/micasense/utils.py
@@ -23,11 +23,11 @@
import numpy as np
-def raw_image_to_radiance(meta, imageRaw):
+def raw_image_to_radiance(meta, image_raw):
# get image dimensions
- imageRaw = imageRaw.T
- xDim = imageRaw.shape[0]
- yDim = imageRaw.shape[1]
+ image_raw = image_raw.T
+ xDim = image_raw.shape[0]
+ yDim = image_raw.shape[1]
# get radiometric calibration factors
@@ -40,11 +40,11 @@ def raw_image_to_radiance(meta, imageRaw):
# get dark current pixel values
# get number of stored values
black_levels = [float(val) for val in meta.get_item('EXIF:BlackLevel').split(' ')]
- blackLevel = np.array(black_levels)
- darkLevel = blackLevel.mean()
+ black_level = np.array(black_levels)
+ dark_level = black_level.mean()
# get exposure time & gain (gain = ISO/100)
- exposureTime = float(meta.get_item('EXIF:ExposureTime'))
+ exposure_time = float(meta.get_item('EXIF:ExposureTime'))
gain = float(meta.get_item('EXIF:ISOSpeed')) / 100.0
# apply image correction methods to raw image
@@ -53,12 +53,12 @@ def raw_image_to_radiance(meta, imageRaw):
V, x, y = vignette_map(meta, xDim, yDim)
# row gradient correction
- R = 1.0 / (1.0 + a2 * y / exposureTime - a3 * y)
+ R = 1.0 / (1.0 + a2 * y / exposure_time - a3 * y)
# subtract the dark level and adjust for vignette and row gradient
- L = V * R * (imageRaw - darkLevel)
+ L = V * R * (image_raw - dark_level)
- # Floor any negative radiances to zero (can happend due to noise around blackLevel)
+ # Floor any negative radiance's to zero (can happen due to noise around black_level)
L[L < 0] = 0
# L = np.round(L).astype(np.uint16)
@@ -67,43 +67,57 @@ def raw_image_to_radiance(meta, imageRaw):
# multiply with the radiometric calibration coefficient
# need to normalize by 2^16 for 16 bit images
# because coefficients are scaled to work with input values of max 1.0
- bitsPerPixel = meta.get_item('EXIF:BitsPerSample')
- bitDepthMax = float(2 ** bitsPerPixel)
- radianceImage = L.astype(float) / (gain * exposureTime) * a1 / bitDepthMax
+ bits_per_pixel = meta.get_item('EXIF:BitsPerSample')
+ bit_depth_max = float(2 ** bits_per_pixel)
+ radiance_image = L.astype(float) / (gain * exposure_time) * a1 / bit_depth_max
# return both the radiance compensated image and the DN corrected image, for the
# sake of the tutorial and visualization
- return radianceImage.T, L.T, V.T, R.T
+ return radiance_image.T, L.T, V.T, R.T
-def vignette_map(meta, xDim, yDim):
- # get vignette center
- xVignette = float(meta.get_item('XMP:VignettingCenter', 0))
- yVignette = float(meta.get_item('XMP:VignettingCenter', 1))
-
- # get vignette polynomial
- NvignettePoly = meta.size('XMP:VignettingPolynomial')
- vignettePolyList = [float(meta.get_item('XMP:VignettingPolynomial', i)) for i in range(NvignettePoly)]
-
- # reverse list and append 1., so that we can call with numpy polyval
- vignettePolyList.reverse()
- vignettePolyList.append(1.)
- vignettePoly = np.array(vignettePolyList)
-
- # perform vignette correction
- # get coordinate grid across image
- x, y = np.meshgrid(np.arange(xDim), np.arange(yDim))
-
+def vignette_map(meta, x_dim, y_dim):
+ # get coordinate grid across image, seem swapped because of transposed vignette
+ x, y = np.meshgrid(np.arange(x_dim), np.arange(y_dim))
# meshgrid returns transposed arrays
x = x.T
y = y.T
- # compute matrix of distances from image center
- r = np.hypot((x - xVignette), (y - yVignette))
-
- # compute the vignette polynomial for each distance - we divide by the polynomial so that the
- # corrected image is image_corrected = image_original * vignetteCorrection
- vignette = 1. / np.polyval(vignettePoly, r)
+ vignetting_center_size = meta.size('XMP:VignettingCenter')
+ vignetting_polynomial_2d_size = meta.size('XMP:VignettingPolynomial2D')
+
+ # if we have a radial poly
+ if vignetting_center_size > 0:
+ # get vignette center
+ x_vignette = float(meta.get_item('XMP:VignettingCenter', 0))
+ y_vignette = float(meta.get_item('XMP:VignettingCenter', 1))
+
+ # get vignette polynomial
+ nvignette_poly = meta.size('XMP:VignettingPolynomial')
+ vignette_poly_list = [float(meta.get_item('XMP:VignettingPolynomial', i)) for i in range(nvignette_poly)]
+
+ # reverse list and append 1., so that we can call with numpy polyval
+ vignette_poly_list.reverse()
+ vignette_poly_list.append(1.)
+ vignette_poly = np.array(vignette_poly_list)
+
+ # compute matrix of distances from image center
+ r = np.hypot((x - x_vignette), (y - y_vignette))
+
+ # compute the vignette polynomial for each distance - we divide by the polynomial so that the
+ # corrected image is image_corrected = image_original * vignetteCorrection
+ vignette = 1. / np.polyval(vignette_poly, r)
+ elif vignetting_polynomial_2d_size > 0: # 2d polynomial
+ xv = x.T / x_dim
+ yv = y.T / y_dim
+ k = meta.vignette_polynomial2D()
+ e = meta.vignette_polynomial2Dexponents()
+ p2 = np.zeros_like(xv, dtype=float)
+ for i, c in enumerate(k):
+ ex = e[2 * i]
+ ey = e[2 * i + 1]
+ p2 += c * xv ** ex * yv ** ey
+ vignette = (1. / p2).T
return vignette, x, y
@@ -115,34 +129,29 @@ def focal_plane_resolution_px_per_mm(meta):
def focal_length_mm(meta):
units = meta.get_item('XMP:PerspectiveFocalLengthUnits')
- focal_length_mm = 0.0
if units == 'mm':
- focal_length_mm = float(meta.get_item('XMP:PerspectiveFocalLength'))
+ local_focal_length_mm = float(meta.get_item('XMP:PerspectiveFocalLength'))
else:
focal_length_px = float(meta.get_item('XMP:PerspectiveFocalLength'))
- focal_length_mm = focal_length_px / focal_plane_resolution_px_per_mm(meta)[0]
- return focal_length_mm
+ local_focal_length_mm = focal_length_px / focal_plane_resolution_px_per_mm(meta)[0]
+ return local_focal_length_mm
def correct_lens_distortion(meta, image):
# get lens distortion parameters
- Ndistortion = meta.size('XMP:PerspectiveDistortion')
- distortionParameters = np.array([float(meta.get_item('XMP:PerspectiveDistortion', i)) for i in range(Ndistortion)])
+ ndistortion = meta.size('XMP:PerspectiveDistortion')
+ distortion_parameters = np.array([float(meta.get_item('XMP:PerspectiveDistortion', i)) for i in range(ndistortion)])
# get the two principal points
- pp = np.array(meta.get_item('XMP:PrincipalPoint').split(',')).astype(np.float)
+ pp = np.array(meta.get_item('XMP:PrincipalPoint').split(',')).astype(float)
# values in pp are in [mm] and need to be rescaled to pixels
- FocalPlaneXResolution = float(meta.get_item('EXIF:FocalPlaneXResolution'))
- FocalPlaneYResolution = float(meta.get_item('EXIF:FocalPlaneYResolution'))
+ focal_plane_x_resolution = float(meta.get_item('EXIF:FocalPlaneXResolution'))
+ focal_plane_y_resolution = float(meta.get_item('EXIF:FocalPlaneYResolution'))
- cX = pp[0] * FocalPlaneXResolution
- cY = pp[1] * FocalPlaneYResolution
- # k = distortionParameters[0:3] # seperate out k -parameters
- # p = distortionParameters[3::] # separate out p - parameters
- # fx = fy = float(meta.get_item('XMP:PerspectiveFocalLength'))
- fx = fy = focal_length_mm(meta) * FocalPlaneXResolution
+ cX = pp[0] * focal_plane_x_resolution
+ cY = pp[1] * focal_plane_y_resolution
+ fx = fy = focal_length_mm(meta) * focal_plane_x_resolution
# apply perspective distortion
-
h, w = image.shape
# set up camera matrix for cv2
@@ -154,8 +163,7 @@ def correct_lens_distortion(meta, image):
cam_mat[1, 2] = cY
# set up distortion coefficients for cv2
- # dist_coeffs = np.array(k[0],k[1],p[0],p[1],k[2]])
- dist_coeffs = distortionParameters[[0, 1, 3, 4, 2]]
+ dist_coeffs = distortion_parameters[[0, 1, 3, 4, 2]]
new_cam_mat, _ = cv2.getOptimalNewCameraMatrix(cam_mat, dist_coeffs, (w, h), 1)
map1, map2 = cv2.initUndistortRectifyMap(cam_mat,
@@ -165,5 +173,4 @@ def correct_lens_distortion(meta, image):
(w, h),
cv2.CV_32F) # cv2.CV_32F for 32 bit floats
# compute the undistorted 16 bit image
- undistortedImage = cv2.remap(image, map1, map2, cv2.INTER_LINEAR)
- return undistortedImage
+ return cv2.remap(image, map1, map2, cv2.INTER_LINEAR)
diff --git a/micasense_conda_env.yml b/micasense_conda_env.yml
index 2ce10af0..845e1f77 100644
--- a/micasense_conda_env.yml
+++ b/micasense_conda_env.yml
@@ -2,8 +2,8 @@ name: micasense
channels:
- conda-forge
dependencies:
- - python=3.7
- - opencv=4.1
+ - python=3.8
+ - opencv=4.8
- numpy
- jupyter
- matplotlib
@@ -23,6 +23,6 @@ dependencies:
- pip:
- pyzbar
- mapboxgl
- - git+https://github.com/smarnach/pyexiftool.git#egg=pyexiftoolpy
+ - pyexiftool
- jenkspy
- rawpy
diff --git a/tests/conftest.py b/tests/conftest.py
index ed767c1c..d9f37378 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -23,156 +23,175 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
+import glob
+from pathlib import Path
+
import pytest
-import os, glob
import micasense.capture as capture
import micasense.image as image
import micasense.metadata as metadata
-@pytest.fixture()
-def files_dir():
- return os.path.join('data', '0000SET', '000')
@pytest.fixture()
-def altum_files_dir():
- return os.path.join('data', 'ALTUM1SET', '000')
+def rededge_files_dir():
+ return Path(__file__).parent.parent / 'data' / 'REDEDGE-MX'
-@pytest.fixture()
-def ten_band_files_dir():
- return os.path.join('data', '10BANDSET', '000')
@pytest.fixture()
-def panel_rededge_file_list(files_dir):
- return glob.glob(os.path.join(files_dir, 'IMG_0000_*.tif'))
+def panel_rededge_file_list(rededge_files_dir: Path):
+ return glob.glob(str(rededge_files_dir / 'IMG_0001_*.tif'))
+
@pytest.fixture()
-def non_panel_rededge_file_list(files_dir):
- return glob.glob(os.path.join(files_dir, 'IMG_0001_*.tif'))
+def non_panel_rededge_file_list(rededge_files_dir: Path):
+ return glob.glob(str(rededge_files_dir / 'IMG_0020_*.tif'))
+
@pytest.fixture()
-def bad_file_list(files_dir):
- file1 = os.path.join(files_dir, 'IMG_0000_1.tif')
- file2 = os.path.join(files_dir, 'IMG_0001_1.tif')
+def bad_file_list(rededge_files_dir: Path):
+ file1 = str(rededge_files_dir / 'IMG_0020_1.tif')
+ file2 = str(rededge_files_dir / 'IMG_0001_1.tif')
return [file1, file2]
-@pytest.fixture()
-def panel_altum_file_list(altum_files_dir):
- return glob.glob(os.path.join(altum_files_dir, 'IMG_0000_*.tif'))
@pytest.fixture()
def panel_rededge_capture(panel_rededge_file_list):
return capture.Capture.from_filelist(panel_rededge_file_list)
+
@pytest.fixture()
def non_panel_rededge_capture(non_panel_rededge_file_list):
return capture.Capture.from_filelist(non_panel_rededge_file_list)
+
@pytest.fixture()
-def panel_10band_rededge_file_list(ten_band_files_dir):
- return glob.glob(os.path.join(ten_band_files_dir, 'IMG_0000_*.tif'))
+def img(rededge_files_dir: Path):
+ return image.Image(str(rededge_files_dir / 'IMG_0001_1.tif'))
+
@pytest.fixture()
-def flight_10band_rededge_file_list(ten_band_files_dir):
- return glob.glob(os.path.join(ten_band_files_dir, 'IMG_0431_*.tif'))
+def img2(rededge_files_dir: Path):
+ return image.Image(str(rededge_files_dir / 'IMG_0001_2.tif'))
+
@pytest.fixture()
-def panel_altum_capture(panel_altum_file_list):
- imgs = [image.Image(fle) for fle in panel_altum_file_list]
- return capture.Capture(imgs)
+def ten_band_files_dir():
+ return Path(__file__).parent.parent / 'data' / 'REDEDGE-MX-DUAL'
+
@pytest.fixture()
-def non_panel_altum_file_list(altum_files_dir):
- return glob.glob(os.path.join(altum_files_dir, 'IMG_0008_*.tif'))
+def panel_10band_rededge_file_list(ten_band_files_dir: Path):
+ return glob.glob(str(ten_band_files_dir / 'IMG_0000_*.tif'))
+
@pytest.fixture()
-def non_panel_altum_capture(non_panel_altum_file_list):
- imgs = [image.Image(fle) for fle in non_panel_altum_file_list]
- return capture.Capture(imgs)
+def flight_10band_rededge_file_list(ten_band_files_dir: Path):
+ return glob.glob(str(ten_band_files_dir / 'IMG_0431_*.tif'))
+
@pytest.fixture()
-def panel_image_name():
- image_path = os.path.join('data', '0000SET', '000')
- return os.path.join(image_path, 'IMG_0000_1.tif')
+def panel_10band_rededge_capture(panel_10band_rededge_file_list):
+ return capture.Capture.from_filelist(panel_10band_rededge_file_list)
+
@pytest.fixture()
-def panel_image_name_red():
- image_path = os.path.join('data', '0000SET', '000')
- return os.path.join(image_path, 'IMG_0000_2.tif')
+def flight_10band_rededge_capture(flight_10band_rededge_file_list):
+ return capture.Capture.from_filelist(flight_10band_rededge_file_list)
+
@pytest.fixture()
-def flight_image_name():
- image_path = os.path.join('data', '0000SET', '000')
- return os.path.join(image_path, 'IMG_0001_1.tif')
+def panel_image_name(rededge_files_dir: Path):
+ return str(rededge_files_dir / 'IMG_0001_1.tif')
+
@pytest.fixture()
-def altum_panel_image_name(altum_files_dir):
- return os.path.join(altum_files_dir, 'IMG_0000_1.tif')
+def panel_image_name_red(rededge_files_dir: Path):
+ return str(rededge_files_dir / 'IMG_0001_2.tif')
+
@pytest.fixture()
-def altum_lwir_image_name(altum_files_dir):
- return os.path.join(altum_files_dir, 'IMG_0000_6.tif')
+def flight_image_name(rededge_files_dir: Path):
+ return str(rededge_files_dir / 'IMG_0020_1.tif')
+
@pytest.fixture()
-def altum_flight_image_name(altum_files_dir):
- return os.path.join(altum_files_dir, 'IMG_0008_1.tif')
+def altum_files_dir():
+ return Path(__file__).parent.parent / 'data' / 'ALTUM'
+
@pytest.fixture()
-def img(files_dir):
- return image.Image(os.path.join(files_dir,'IMG_0000_1.tif'))
+def panel_altum_file_list(altum_files_dir):
+ return glob.glob(str(altum_files_dir / 'IMG_0000_*.tif'))
+
@pytest.fixture()
-def img2(files_dir):
- return image.Image(os.path.join(files_dir,'IMG_0000_2.tif'))
+def panel_altum_capture(panel_altum_file_list):
+ imgs = [image.Image(fle) for fle in panel_altum_file_list]
+ return capture.Capture(imgs)
+
+
+@pytest.fixture()
+def non_panel_altum_file_list(altum_files_dir: Path):
+ return glob.glob(str(altum_files_dir / 'IMG_0021_*.tif'))
+
+
+@pytest.fixture()
+def non_panel_altum_capture(non_panel_altum_file_list):
+ imgs = [image.Image(fle) for fle in non_panel_altum_file_list]
+ return capture.Capture(imgs)
+
+
+@pytest.fixture()
+def altum_panel_image_name(altum_files_dir: Path):
+ return str(altum_files_dir / 'IMG_0000_1.tif')
+
+
+@pytest.fixture()
+def altum_lwir_image_name(altum_files_dir: Path):
+ return str(altum_files_dir / 'IMG_0000_6.tif')
+
+
+@pytest.fixture()
+def altum_flight_image_name(altum_files_dir: Path):
+ return str(altum_files_dir / 'IMG_0021_1.tif')
+
@pytest.fixture()
def panel_altum_file_name(altum_files_dir):
- return os.path.join(altum_files_dir, 'IMG_0000_1.tif')
+ return str(altum_files_dir / 'IMG_0000_1.tif')
+
@pytest.fixture()
def panel_altum_image(panel_altum_file_name):
return image.Image(panel_altum_file_name)
+
@pytest.fixture()
def altum_flight_image(altum_flight_image_name):
return image.Image(altum_flight_image_name)
-@pytest.fixture()
-def non_existant_file_name(altum_files_dir):
- return os.path.join(altum_files_dir, 'NOFILE.tif')
@pytest.fixture()
-def altum_lwir_image(altum_files_dir):
- return image.Image(os.path.join(altum_files_dir, 'IMG_0000_6.tif'))
+def non_existant_file_name(altum_files_dir: Path):
+ return str(altum_files_dir / 'NOFILE.tif')
-@pytest.fixture()
-def meta():
- image_path = os.path.join('data', '0000SET', '000')
- return metadata.Metadata(os.path.join(image_path, 'IMG_0000_1.tif'))
@pytest.fixture()
-def meta_v3():
- image_path = os.path.join('data', '0001SET', '000')
- return metadata.Metadata(os.path.join(image_path, 'IMG_0002_4.tif'))
+def altum_lwir_image(altum_files_dir: Path):
+ return image.Image(str(altum_files_dir / 'IMG_0000_6.tif'))
-@pytest.fixture()
-def meta_bad_exposure():
- image_path = os.path.join('data', '0001SET', '000')
- return metadata.Metadata(os.path.join(image_path, 'IMG_0003_1.tif'))
@pytest.fixture()
-def meta_altum_dls2(altum_flight_image_name):
- return metadata.Metadata(altum_flight_image_name)
+def meta(rededge_files_dir: Path):
+ return metadata.Metadata(str(rededge_files_dir / 'IMG_0001_1.tif'))
-@pytest.fixture()
-def bad_dls2_horiz_irr_image():
- image_path = os.path.join('data', 'ALTUM0SET', '000')
- return image.Image(os.path.join(image_path, 'IMG_0000_1.tif'))
@pytest.fixture()
-def panel_10band_rededge_capture(panel_10band_rededge_file_list):
- return capture.Capture.from_filelist(panel_10band_rededge_file_list)
+def meta_bad_exposure(rededge_files_dir: Path):
+ return metadata.Metadata(str(rededge_files_dir / 'IMG_0020_1.tif'))
+
@pytest.fixture()
-def flight_10band_rededge_capture(flight_10band_rededge_file_list):
- return capture.Capture.from_filelist(flight_10band_rededge_file_list)
\ No newline at end of file
+def meta_altum_dls2(altum_flight_image_name):
+ return metadata.Metadata(altum_flight_image_name)
diff --git a/tests/test_capture.py b/tests/test_capture.py
index ce83dedb..d786796c 100644
--- a/tests/test_capture.py
+++ b/tests/test_capture.py
@@ -23,37 +23,45 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
+import os
+
+import numpy as np
import pytest
-import os, glob
import micasense.capture as capture
import micasense.image as image
+
def test_from_images(panel_rededge_file_list):
imgs = [image.Image(fle) for fle in panel_rededge_file_list]
cap = capture.Capture(imgs)
assert cap is not None
assert len(cap.images) == len(panel_rededge_file_list)
+
def test_from_filelist(panel_rededge_file_list):
cap = capture.Capture.from_filelist(panel_rededge_file_list)
assert cap is not None
assert len(cap.images) == len(panel_rededge_file_list)
+
def test_from_single_file(panel_image_name):
cap = capture.Capture.from_file(panel_image_name)
assert cap is not None
+
def test_append_single_file(panel_rededge_file_list):
cap = capture.Capture.from_file(panel_rededge_file_list[0])
assert len(cap.images) == 1
cap.append_file(panel_rededge_file_list[1])
assert len(cap.images) == 2
+
def test_from_different_ids(bad_file_list):
with pytest.raises(RuntimeError):
cap = capture.Capture.from_filelist(bad_file_list)
+
def test_append_single(panel_rededge_file_list):
imgs = [image.Image(fle) for fle in panel_rededge_file_list]
cap = capture.Capture(imgs[0])
@@ -62,6 +70,7 @@ def test_append_single(panel_rededge_file_list):
cap.append_image(img)
assert len(cap.images) == 5
+
def test_append_list(panel_rededge_file_list):
imgs = [image.Image(fle) for fle in panel_rededge_file_list]
cap = capture.Capture(imgs[0])
@@ -69,141 +78,170 @@ def test_append_list(panel_rededge_file_list):
cap.append_images(imgs[1:])
assert len(cap.images) == 5
+
def test_less_than(panel_image_name, flight_image_name):
cap1 = capture.Capture.from_file(panel_image_name)
cap2 = capture.Capture.from_file(flight_image_name)
assert cap1 < cap2
+
def test_greater_than(panel_image_name, flight_image_name):
cap1 = capture.Capture.from_file(panel_image_name)
cap2 = capture.Capture.from_file(flight_image_name)
assert cap2 > cap1
+
def test_equal(panel_image_name, panel_image_name_red):
cap1 = capture.Capture.from_file(panel_image_name)
cap2 = capture.Capture.from_file(panel_image_name_red)
assert cap2 == cap1
+
def test_uct_time(panel_image_name):
cap1 = capture.Capture.from_file(panel_image_name)
- assert cap1.utc_time().isoformat() == '2017-10-19T20:40:39.200174+00:00'
+ assert cap1.utc_time().isoformat() == '2022-04-06T18:50:25.983430+00:00'
+
def test_location(panel_image_name):
cap1 = capture.Capture.from_file(panel_image_name)
loc = cap1.location()
+ print(loc)
assert len(loc) == 3
- assert loc == (36.576096, -119.4352689, 101.861)
+ assert loc == (47.7036143, -122.1414373, 6.728)
+
def test_dls_single_file(panel_image_name):
cap1 = capture.Capture.from_file(panel_image_name)
assert cap1.dls_present()
- assert cap1.dls_irradiance()[0] == pytest.approx(1.0101948, 1e-4)
+ print(cap1.dls_irradiance()[0])
+ print(cap1.dls_pose())
+ assert cap1.dls_irradiance()[0] == pytest.approx(0.77810447, 1e-4)
pose = cap1.dls_pose()
+ print(pose)
assert len(pose) == 3
- assert pose[0] == pytest.approx(-3.070222992336269)
- assert pose[1] == pytest.approx(-0.18812839845718335)
- assert pose[2] == pytest.approx(-0.013387829297356699)
+ assert pose[0] == pytest.approx(-2.0091497634122724)
+ assert pose[1] == pytest.approx(0.018554597483870183)
+ assert pose[2] == pytest.approx(0.031269217556393974)
+
def test_dls_group(panel_rededge_capture):
assert panel_rededge_capture.dls_present()
irradiance = panel_rededge_capture.dls_irradiance()
assert len(irradiance) == 5
- assert irradiance[0] == pytest.approx(1.0101948, 1e-4)
+ print(irradiance[0])
+ print(panel_rededge_capture.dls_pose())
+ assert irradiance[0] == pytest.approx(0.77810447, 1e-4)
pose = panel_rededge_capture.dls_pose()
+ print(pose)
assert len(pose) == 3
- assert pose[0] == pytest.approx(-3.070222992336269)
- assert pose[1] == pytest.approx(-0.18812839845718335)
- assert pose[2] == pytest.approx(-0.013387829297356699)
+ assert pose[0] == pytest.approx(-2.0091497634122724)
+ assert pose[1] == pytest.approx(0.018554597483870183)
+ assert pose[2] == pytest.approx(0.031269217556393974)
+
def test_panel_radiance(panel_rededge_capture):
rad = panel_rededge_capture.panel_radiance()
- expected_rad = [0.17028382320603955,
- 0.17940027272297152,
- 0.1622172746785481,
- 0.10647021248769974,
- 0.13081077851565506]
+ print(rad)
+ expected_rad = [0.17909220357022979,
+ 0.1805512169681595,
+ 0.1577359026273932,
+ 0.10556279304323357,
+ 0.13221390933733143]
assert len(rad) == len(expected_rad)
- for i,_ in enumerate(expected_rad):
+ for i, _ in enumerate(expected_rad):
assert rad[i] == pytest.approx(expected_rad[i], rel=0.001)
+
def test_panel_raw(panel_rededge_capture):
raw = panel_rededge_capture.panel_raw()
print(raw)
- expected_raw = [45406.753893482026,
- 46924.919447148139,
- 53240.810340812051,
- 56187.417482757308,
- 54479.170371812339]
+ expected_raw = [28585.13736620175,
+ 24613.08368472267,
+ 33435.07799487508,
+ 31492.43415504379,
+ 30858.20096]
assert len(raw) == len(expected_raw)
- for i,_ in enumerate(expected_raw):
+ for i, _ in enumerate(expected_raw):
assert raw[i] == pytest.approx(expected_raw[i], rel=0.001)
+
def test_panel_irradiance(panel_rededge_capture):
- panel_reflectance_by_band = [0.67, 0.69, 0.68, 0.61, 0.67]
+ panel_reflectance_by_band = [0.49, 0.49, 0.49, 0.49, 0.49]
rad = panel_rededge_capture.panel_irradiance(panel_reflectance_by_band)
- expected_rad = [0.79845135523772681, 0.81681533164998943, 0.74944205649335915, 0.54833776619262586, 0.61336444894797537]
+ expected_rad = [1.1482341858192686, 1.15758852413034, 1.0113101079623947, 0.6768067247286578, 0.8476780536256069]
assert len(rad) == len(expected_rad)
- for i,_ in enumerate(expected_rad):
+ for i, _ in enumerate(expected_rad):
assert rad[i] == pytest.approx(expected_rad[i], rel=0.001)
-def test_panel_albedo_not_preset(panel_rededge_capture):
- assert panel_rededge_capture.panels_in_all_expected_images()
- assert panel_rededge_capture.panel_albedo() == None
def test_panel_albedo_preset(panel_altum_capture):
assert panel_altum_capture.panels_in_all_expected_images()
- assert panel_altum_capture.panel_albedo() == pytest.approx(5*[0.52],abs=0.01)
+ assert panel_altum_capture.panel_albedo() == pytest.approx(5 * [0.49], abs=0.01)
+
def test_detect_panels_in_panel_image(panel_rededge_capture):
assert panel_rededge_capture.detect_panels() == 5
assert panel_rededge_capture.panels_in_all_expected_images() == True
+
def test_no_detect_panels_in_flight_image(non_panel_rededge_capture):
assert non_panel_rededge_capture.detect_panels() == 0
assert non_panel_rededge_capture.panels_in_all_expected_images() == False
+
def test_band_names(panel_rededge_capture):
assert panel_rededge_capture.band_names() == ['Blue', 'Green', 'Red', 'NIR', 'Red edge']
+
def test_band_names_lower(panel_rededge_capture):
assert panel_rededge_capture.band_names_lower() == ['blue', 'green', 'red', 'nir', 'red edge']
+
def test_altum_eo_lw_indices(panel_altum_capture):
- assert panel_altum_capture.eo_indices() == [0,1,2,3,4]
+ assert panel_altum_capture.eo_indices() == [0, 1, 2, 3, 4]
assert panel_altum_capture.lw_indices() == [5]
+
def test_rededge_eo_lw_indices(panel_rededge_capture):
- assert panel_rededge_capture.eo_indices() == [0,1,2,3,4]
+ assert panel_rededge_capture.eo_indices() == [0, 1, 2, 3, 4]
assert panel_rededge_capture.lw_indices() == []
+
def test_altum_images(non_panel_altum_file_list):
imgs = [image.Image(fle) for fle in non_panel_altum_file_list]
cap = capture.Capture(imgs)
assert cap is not None
assert len(cap.images) == len(non_panel_altum_file_list)
+
def test_altum_from_filelist(non_panel_altum_file_list):
cap = capture.Capture.from_filelist(non_panel_altum_file_list)
assert cap is not None
assert len(cap.images) == len(non_panel_altum_file_list)
+
def test_altum_from_single_file(altum_flight_image_name):
cap = capture.Capture.from_file(altum_flight_image_name)
assert cap is not None
+
def test_altum_horizontal_irradiance(non_panel_altum_capture):
assert non_panel_altum_capture.dls_present()
- good_irradiance = [1.222, 1.079, 0.914, 0.587, 0.715, 0.0]
+ good_irradiance = [1.1215395307329492, 1.0496371984570443, 0.9390573858775944, 0.5691781852317392,
+ 0.6800663660628287, 0]
assert non_panel_altum_capture.dls_irradiance() == pytest.approx(good_irradiance, 1e-3)
+
def test_altum_panels(panel_altum_capture):
assert panel_altum_capture.panels_in_all_expected_images() == True
+
@pytest.fixture()
def aligned_altum_capture(non_panel_altum_capture):
non_panel_altum_capture.create_aligned_capture(img_type='radiance')
return non_panel_altum_capture
+
def test_stack_export(aligned_altum_capture, tmpdir):
pathstr = str(tmpdir.join('test_bgrent.tiff'))
aligned_altum_capture.save_capture_as_stack(pathstr)
@@ -211,6 +249,7 @@ def test_stack_export(aligned_altum_capture, tmpdir):
if tmpdir.check():
tmpdir.remove()
+
def test_rgb_jpg(aligned_altum_capture, tmpdir):
pathstr = str(tmpdir.join('test_rgb.jpg'))
aligned_altum_capture.save_capture_as_rgb(pathstr)
@@ -218,6 +257,7 @@ def test_rgb_jpg(aligned_altum_capture, tmpdir):
if tmpdir.check():
tmpdir.remove()
+
def test_rgb_png(aligned_altum_capture, tmpdir):
pathstr = str(tmpdir.join('test_rgb.png'))
aligned_altum_capture.save_capture_as_rgb(pathstr)
@@ -225,20 +265,22 @@ def test_rgb_png(aligned_altum_capture, tmpdir):
if tmpdir.check():
tmpdir.remove()
+
def test_rgb_jpg_decimation(aligned_altum_capture, tmpdir):
import imageio
- decimations = [2,5,8]
+ decimations = [2, 5, 8]
for decimation in decimations:
pathstr = str(tmpdir.join('test_rgb_{}x.jpg'.format(decimation)))
aligned_altum_capture.save_capture_as_rgb(pathstr, downsample=decimation)
assert os.path.exists(pathstr)
img = imageio.imread(pathstr)
- assert img.shape[0] == round(float(aligned_altum_capture.aligned_shape()[0])/float(decimation))
- assert img.shape[1] == round(float(aligned_altum_capture.aligned_shape()[1])/float(decimation))
+ assert img.shape[0] == round(float(aligned_altum_capture.aligned_shape()[0]) / float(decimation))
+ assert img.shape[1] == round(float(aligned_altum_capture.aligned_shape()[1]) / float(decimation))
if tmpdir.check():
tmpdir.remove()
+
def test_save_thermal_over_rgb(aligned_altum_capture, tmpdir):
pathstr = str(tmpdir.join('test_thermal_rgb.png'))
aligned_altum_capture.save_thermal_over_rgb(pathstr)
@@ -246,35 +288,42 @@ def test_save_thermal_over_rgb(aligned_altum_capture, tmpdir):
if tmpdir.check():
tmpdir.remove()
+
def test_has_rig_relatives(non_panel_altum_capture):
assert non_panel_altum_capture.has_rig_relatives() == True
-def test_no_rig_relatives(non_panel_rededge_file_list):
- cap = capture.Capture.from_filelist(non_panel_rededge_file_list)
- assert cap.has_rig_relatives() == False
def test_panel_albedo(panel_altum_capture):
assert panel_altum_capture.detect_panels() == 5
assert panel_altum_capture.panels_in_all_expected_images()
- good_panel_albedo = [0.5282, 0.5274, 0.5263, 0.5246, 0.5258]
+ good_panel_albedo = [0.488375, 0.4876666666666666, 0.4867666666666667, 0.48533333333333334, 0.48635833333333334]
assert panel_altum_capture.panel_albedo() == pytest.approx(good_panel_albedo, 1e-4)
+
def test_panel_albedo_no_detect(panel_altum_capture):
- good_panel_albedo = [0.5282, 0.5274, 0.5263, 0.5246, 0.5258]
+ good_panel_albedo = [0.488375, 0.4876666666666666, 0.4867666666666667, 0.48533333333333334, 0.48635833333333334]
assert panel_altum_capture.panel_albedo() == pytest.approx(good_panel_albedo, 1e-4)
+
def test_10_band_capture_loads(panel_10band_rededge_file_list):
- print(panel_10band_rededge_file_list)
cap = capture.Capture.from_filelist(panel_10band_rededge_file_list)
assert cap.num_bands == 10
+
def test_10_band_panel(panel_10band_rededge_file_list):
cap = capture.Capture.from_filelist(panel_10band_rededge_file_list)
assert cap.detect_panels() == 10
assert cap.panels_in_all_expected_images() == True
+
def test_10_band_irradiance(flight_10band_rededge_capture):
assert flight_10band_rededge_capture.dls_present()
test_irradiance = flight_10band_rededge_capture.dls_irradiance()
good_irradiance = [0.67305, 0.62855, 0.55658, 0.34257, 0.41591, 0.57470, 0.64203, 0.53739, 0.48215, 0.44563]
- assert test_irradiance == pytest.approx(good_irradiance, abs = 1e-5)
+ assert test_irradiance == pytest.approx(good_irradiance, abs=1e-5)
+
+
+def test_get_warp_matrices(panel_altum_capture):
+ for i in range(len(panel_altum_capture.images)):
+ w = panel_altum_capture.get_warp_matrices(i)
+ np.testing.assert_allclose(np.eye(3), w[i], atol=1e-6)
diff --git a/tests/test_dls.py b/tests/test_dls.py
index d439d65d..27138ec1 100644
--- a/tests/test_dls.py
+++ b/tests/test_dls.py
@@ -23,94 +23,104 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-import pytest
-import os, glob
-import numpy as np
-import math
import datetime
+import math
+
+import numpy as np
+import pytest
import micasense.dls as dls
-import micasense.image as image
+
# pysolar changed their coordinate system from South-based to north-based between 0.6 and 0.8
# we add some tests here to help ensure we captured that change properly
def test_ned_from_pysolar_north():
- assert dls.ned_from_pysolar(0,np.radians(45)) == pytest.approx([0.707, 0, -0.707], 0.01)
+ assert dls.ned_from_pysolar(0, np.radians(45)) == pytest.approx([0.707, 0, -0.707], 0.01)
+
def test_ned_from_pysolar_northeast():
- assert dls.ned_from_pysolar(np.radians(45),np.radians(45)) == pytest.approx([0.50, 0.5, -0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(45), np.radians(45)) == pytest.approx([0.50, 0.5, -0.707], 0.01)
+
def test_ned_from_pysolar_east():
- assert dls.ned_from_pysolar(np.radians(90),np.radians(45)) == pytest.approx([0, 0.707, -0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(90), np.radians(45)) == pytest.approx([0, 0.707, -0.707], 0.01)
+
def test_ned_from_pysolar_southeast():
- assert dls.ned_from_pysolar(np.radians(135),np.radians(45)) == pytest.approx([-0.50, 0.5, -0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(135), np.radians(45)) == pytest.approx([-0.50, 0.5, -0.707], 0.01)
+
def test_ned_from_pysolar_south():
- assert dls.ned_from_pysolar(np.radians(180),np.radians(45)) == pytest.approx([-0.707, 0, -0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(180), np.radians(45)) == pytest.approx([-0.707, 0, -0.707], 0.01)
+
def test_ned_from_pysolar_southwest():
- assert dls.ned_from_pysolar(np.radians(225),np.radians(45)) == pytest.approx([-0.50, -0.5, -0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(225), np.radians(45)) == pytest.approx([-0.50, -0.5, -0.707], 0.01)
+
def test_ned_from_pysolar_west():
- assert dls.ned_from_pysolar(np.radians(270),np.radians(45)) == pytest.approx([0,-0.707,-0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(270), np.radians(45)) == pytest.approx([0, -0.707, -0.707], 0.01)
+
def test_ned_from_pysolar_northwest():
- assert dls.ned_from_pysolar(np.radians(315),np.radians(45)) == pytest.approx([0.50, -0.5, -0.707], 0.01)
+ assert dls.ned_from_pysolar(np.radians(315), np.radians(45)) == pytest.approx([0.50, -0.5, -0.707], 0.01)
+
def test_pysolar_az_el_vs_usno():
# for simplicity's sake, let's pick a couple places on the prime meridian on the vernal equinox,
# and test those vs the USNO
# https://aa.usno.navy.mil/rstt/onedaytable?ID=AA&year=2019&month=3&day=20&place=&lon_sign=-1&lon_deg=0&lon_min=0&lat_sign=1&lat_deg=51&lat_min=28&tz=0&tz_sign=-1
- lat = 51.4769 #greenwich observatory
+ lat = 51.4769 # greenwich observatory
lon = 0
- dt = datetime.datetime(2019,3,21,12,8,0,tzinfo=datetime.timezone.utc)
- _,_,angle,sunAltitude,sunAzimuth = dls.compute_sun_angle((lat, lon, 0),
- (0,0,0),
- dt,
- np.array([0,0,-1]))
+ dt = datetime.datetime(2019, 3, 21, 12, 8, 0, tzinfo=datetime.timezone.utc)
+ _, _, angle, sunAltitude, sunAzimuth = dls.compute_sun_angle((lat, lon, 0),
+ (0, 0, 0),
+ dt,
+ np.array([0, 0, -1]))
assert angle == pytest.approx(math.radians(lat), abs=0.01)
- assert sunAltitude == pytest.approx(math.radians(90-lat), abs=0.01)
+ assert sunAltitude == pytest.approx(math.radians(90 - lat), abs=0.01)
assert sunAzimuth == pytest.approx(math.pi, abs=0.01)
- #for simplicity's sake, let's pick a couple places on the prime meridian on the vernal equinox
+ # for simplicity's sake, let's pick a couple places on the prime meridian on the vernal equinox
lat = 0
lon = 0
- dt = datetime.datetime(2019,3,20,12,8,0,tzinfo=datetime.timezone.utc)
- _,_,angle,sunAltitude,sunAzimuth = dls.compute_sun_angle((lat, lon, 0),
- (0,0,0),
- dt,
- np.array([0,0,-1]))
+ dt = datetime.datetime(2019, 3, 20, 12, 8, 0, tzinfo=datetime.timezone.utc)
+ _, _, angle, sunAltitude, sunAzimuth = dls.compute_sun_angle((lat, lon, 0),
+ (0, 0, 0),
+ dt,
+ np.array([0, 0, -1]))
assert angle == pytest.approx(math.radians(lat), abs=0.01)
- assert sunAltitude == pytest.approx(math.radians(90-lat), abs=0.01)
- #assert sunAzimuth == pytest.approx(math.pi, abs=0.01) # should be straight up, at the equator, don't test elevation
+ assert sunAltitude == pytest.approx(math.radians(90 - lat), abs=0.01)
+ # assert sunAzimuth == pytest.approx(math.pi, abs=0.01) # should be straight up, at the equator, don't test elevation
# middle of the ocean at 45deg sout latitutde
lat = -45
lon = 0
- dt = datetime.datetime(2019,3,20,12,8,0,tzinfo=datetime.timezone.utc)
- _,_,angle,sunAltitude,sunAzimuth = dls.compute_sun_angle((lat, lon, 0),
- (0,0,0),
- dt,
- np.array([0,0,-1]))
+ dt = datetime.datetime(2019, 3, 20, 12, 8, 0, tzinfo=datetime.timezone.utc)
+ _, _, angle, sunAltitude, sunAzimuth = dls.compute_sun_angle((lat, lon, 0),
+ (0, 0, 0),
+ dt,
+ np.array([0, 0, -1]))
assert angle == pytest.approx(math.radians(math.fabs(lat)), abs=0.01)
- assert sunAltitude == pytest.approx(math.radians(90+lat), abs=0.01)
- assert sunAzimuth == pytest.approx(2*math.pi, abs=0.01) # should be due north
+ assert sunAltitude == pytest.approx(math.radians(90 + lat), abs=0.01)
+ assert sunAzimuth == pytest.approx(2 * math.pi, abs=0.01) # should be due north
+
def test_sun_angle_image(img):
if dls.havePysolar:
sun_angle = dls.compute_sun_angle((img.latitude, img.longitude, img.altitude),
(img.dls_yaw, img.dls_pitch, img.dls_roll),
img.utc_time,
- np.array([0,0,-1]))
- assert sun_angle[0] == pytest.approx([-0.711, -0.247, -0.659], abs=0.001)
- assert sun_angle[1] == pytest.approx([-1.87482468e-01, 1.82720334e-05, -9.82267949e-01], abs=0.001)
- assert sun_angle[2] == pytest.approx(0.6754, abs=0.001)
- assert sun_angle[3] == pytest.approx(0.7193, abs=0.001)
- assert sun_angle[4] == pytest.approx(3.4756, abs=0.001)
+ np.array([0, 0, -1]))
+ assert sun_angle[0] == pytest.approx([-0.61171272, 0.34136377, -0.71363739], abs=0.001)
+ assert sun_angle[1] == pytest.approx([0.03617934, 0.00352109, -0.99933911], abs=0.001)
+ assert sun_angle[2] == pytest.approx(0.8062129905713518, abs=0.001)
+ assert sun_angle[3] == pytest.approx(0.7946770189357074, abs=0.001)
+ assert sun_angle[4] == pytest.approx(2.6325931620626153, abs=0.001)
else:
assert True
+
def test_fresnel():
assert dls.fresnel(0.00) == pytest.approx(0.9416, abs=0.001)
assert dls.fresnel(0.01) == pytest.approx(0.9416, abs=0.001)
@@ -118,38 +128,44 @@ def test_fresnel():
assert dls.fresnel(0.99) == pytest.approx(0.903, abs=0.001)
assert dls.fresnel(1.00) == pytest.approx(0.901, abs=0.001)
+
def test_get_orientation_zenith():
- pose = (math.radians(0),math.radians(0), math.radians(0))
- orientation = [0,0,-1]
+ pose = (math.radians(0), math.radians(0), math.radians(0))
+ orientation = [0, 0, -1]
ned = dls.get_orientation(pose, orientation)
- assert ned == pytest.approx([0,0,-1])
+ assert ned == pytest.approx([0, 0, -1])
+
def test_get_orientation_north():
- pose = (math.radians(0),math.radians(-90), math.radians(0))
- orientation = [0,0,-1]
+ pose = (math.radians(0), math.radians(-90), math.radians(0))
+ orientation = [0, 0, -1]
ned = dls.get_orientation(pose, orientation)
- assert ned == pytest.approx([1,0,0])
+ assert ned == pytest.approx([1, 0, 0])
+
def test_get_orientation_east():
- pose = (math.radians(90),math.radians(-90), math.radians(0))
- orientation = [0,0,-1]
+ pose = (math.radians(90), math.radians(-90), math.radians(0))
+ orientation = [0, 0, -1]
ned = dls.get_orientation(pose, orientation)
- assert ned == pytest.approx([0,1,0])
+ assert ned == pytest.approx([0, 1, 0])
+
def test_get_orientation_south():
- pose = (math.radians(0),math.radians(90), math.radians(0))
- orientation = [0,0,-1]
+ pose = (math.radians(0), math.radians(90), math.radians(0))
+ orientation = [0, 0, -1]
ned = dls.get_orientation(pose, orientation)
- assert ned == pytest.approx([-1,0,0])
+ assert ned == pytest.approx([-1, 0, 0])
+
def test_get_orientation_south2():
- pose = (math.radians(180),math.radians(-90), math.radians(0))
- orientation = [0,0,-1]
+ pose = (math.radians(180), math.radians(-90), math.radians(0))
+ orientation = [0, 0, -1]
ned = dls.get_orientation(pose, orientation)
- assert ned == pytest.approx([-1,0,0])
+ assert ned == pytest.approx([-1, 0, 0])
+
def test_get_orientation_west():
- pose = (math.radians(-90),math.radians(-90), math.radians(0))
- orientation = [0,0,-1]
+ pose = (math.radians(-90), math.radians(-90), math.radians(0))
+ orientation = [0, 0, -1]
ned = dls.get_orientation(pose, orientation)
- assert ned == pytest.approx([0,-1,0])
\ No newline at end of file
+ assert ned == pytest.approx([0, -1, 0])
diff --git a/tests/test_image.py b/tests/test_image.py
index 7a95187b..8040ae3b 100644
--- a/tests/test_image.py
+++ b/tests/test_image.py
@@ -23,35 +23,40 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-import pytest
-import os, glob
-import math
import numpy as np
+import pytest
import micasense.image as image
import micasense.panel as panel
+
def test_load_image_metadata(img):
assert img.meta is not None
assert img.meta.band_index() == 0
assert img.meta.camera_make() == 'MicaSense'
- assert img.meta.camera_model() == 'RedEdge'
+ assert img.meta.camera_model() == 'RedEdge-M'
-def test_less_than(img,img2):
+
+def test_less_than(img, img2):
assert img < img2
-def test_greater_than(img,img2):
+
+def test_greater_than(img, img2):
assert img2 > img
-def test_equal(img,img2):
+
+def test_equal(img, img2):
assert img == img
-def test_not_equal(img,img2):
+
+def test_not_equal(img, img2):
assert img != img2
+
def test_load_image_raw(img):
assert img.raw() is not None
+
def test_clear_image_data(img):
assert img.undistorted(img.radiance()) is not None
img.clear_image_data()
@@ -63,48 +68,57 @@ def test_clear_image_data(img):
assert img._Image__undistorted_source is None
assert img._Image__undistorted_image is None
+
def test_reflectance(img):
pan = panel.Panel(img)
- panel_reflectance = 0.5
+ panel_reflectance = 0.50
panel_irradiance = pan.irradiance_mean(panel_reflectance)
reflectance_img = img.reflectance(panel_irradiance)
ref_mean, _, _, _ = pan.region_stats(reflectance_img,
pan.panel_corners())
- assert ref_mean == pytest.approx(panel_reflectance, 1e-4)
+ assert ref_mean == pytest.approx(panel_reflectance, 1e-2)
+
def test_size(img):
- assert img.size() == (1280,960)
+ assert img.size() == (1280, 960)
+
def test_pp_px(img):
- assert img.principal_point_px() == pytest.approx((627.6, 479.9), abs=0.1)
+ assert img.principal_point_px() == pytest.approx((657.402, 478.056), abs=0.1)
+
def test_cv2_camera_matrix(img):
- test_mat = [[1449.4, 0.0, 627.6],
- [ 0.0, 1449.4, 479.9],
- [ 0.0, 0.0, 1.0]]
+ test_mat = [[1441.60555, 0, 657.402667],
+ [0, 1441.60555, 478.056001],
+ [0, 0, 1]]
for idx, row in enumerate(img.cv2_camera_matrix()):
assert row == pytest.approx(test_mat[idx], abs=0.1)
+
def test_altum_panel_image(panel_altum_image):
assert panel_altum_image.size() == (2064, 1544)
assert panel_altum_image.meta.camera_make() == "MicaSense"
assert panel_altum_image.meta.camera_model() == "Altum"
assert panel_altum_image.auto_calibration_image == True
+
def test_altum_flight_image(altum_flight_image):
assert altum_flight_image.meta.camera_make() == "MicaSense"
assert altum_flight_image.meta.camera_model() == "Altum"
assert altum_flight_image.auto_calibration_image == False
+
def test_image_not_file(non_existant_file_name):
with pytest.raises(OSError):
image.Image(non_existant_file_name)
+
def test_altum_lwir_image(altum_lwir_image):
assert altum_lwir_image.meta.band_name() == 'LWIR'
- assert altum_lwir_image.size() == (160,120)
+ assert altum_lwir_image.size() == (160, 120)
assert altum_lwir_image.auto_calibration_image == False
+
def test_altum_image_horizontal_irradiance(altum_flight_image):
assert altum_flight_image.dls_present
solar_el = altum_flight_image.solar_elevation
@@ -112,13 +126,3 @@ def test_altum_image_horizontal_irradiance(altum_flight_image):
scattered_irr = altum_flight_image.scattered_irradiance
good_horiz_irradiance = direct_irr * np.sin(solar_el) + scattered_irr
assert altum_flight_image.horizontal_irradiance == pytest.approx(good_horiz_irradiance, 1e-3)
-
-def test_altum_bad_dls2_horizontal_irradiance(bad_dls2_horiz_irr_image):
- assert bad_dls2_horiz_irr_image.dls_present
- assert bad_dls2_horiz_irr_image.meta.horizontal_irradiance_valid() == False
- solar_el = bad_dls2_horiz_irr_image.solar_elevation
- direct_irr = bad_dls2_horiz_irr_image.direct_irradiance
- scattered_irr = bad_dls2_horiz_irr_image.scattered_irradiance
- good_horiz_irradiance = direct_irr * np.sin(solar_el) + scattered_irr
- assert bad_dls2_horiz_irr_image.horizontal_irradiance == pytest.approx(good_horiz_irradiance, 1e-3)
-
diff --git a/tests/test_imageset.py b/tests/test_imageset.py
index 3f3c5b49..d971c1bf 100644
--- a/tests/test_imageset.py
+++ b/tests/test_imageset.py
@@ -23,31 +23,37 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
+import os
+from pathlib import Path
import pytest
-import os, glob
-import micasense.imageset as imageset
import micasense.capture as capture
-import micasense.image as image
+import micasense.imageset as imageset
+
@pytest.fixture()
def files_dir():
- return os.path.join('data', '0000SET', '000')
+ return Path(__file__).parent.parent / 'data' / 'REDEDGE-MX'
+
progress_val = 0.0
+
+
def progress(p):
global progress_val
progress_val = p
-
+
+
def test_from_captures(files_dir):
- file1 = os.path.join(files_dir, 'IMG_0000_1.tif')
- file2 = os.path.join(files_dir, 'IMG_0001_1.tif')
+ file1 = os.path.join(files_dir, 'IMG_0001_1.tif')
+ file2 = os.path.join(files_dir, 'IMG_0020_1.tif')
cap1 = capture.Capture.from_file(file1)
cap2 = capture.Capture.from_file(file2)
- imgset = imageset.ImageSet([cap1,cap2])
+ imgset = imageset.ImageSet([cap1, cap2])
assert imgset.captures is not None
+
def test_from_directory(files_dir):
global progress_val
progress(0.0)
@@ -56,15 +62,17 @@ def test_from_directory(files_dir):
assert progress_val == 1.0
assert len(imgset.captures) == 2
+
def test_as_nested_lists(files_dir):
imgset = imageset.ImageSet.from_directory(files_dir)
assert imgset is not None
data, columns = imgset.as_nested_lists()
- assert data[0][1] == 36.576096
+ assert data[0][1] == 47.7036143
assert columns[0] == 'timestamp'
+
def test_10_band_from_dir(ten_band_files_dir):
imgset = imageset.ImageSet.from_directory(ten_band_files_dir, progress)
assert imgset is not None
assert progress_val == 1.0
- assert len(imgset.captures) == 2
\ No newline at end of file
+ assert len(imgset.captures) == 2
diff --git a/tests/test_imageutils.py b/tests/test_imageutils.py
index ab0d0f5f..5f022a7f 100644
--- a/tests/test_imageutils.py
+++ b/tests/test_imageutils.py
@@ -23,71 +23,94 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
-
import pytest
-import os, glob
-import cv2
+from numpy import array
-import micasense.imageset as imageset
-import micasense.capture as capture
-import micasense.image as image
import micasense.imageutils as imageutils
-from numpy import array
-from numpy import float32
-
-truth_warp_matrices = [array([[ 1.00523243e+00, -3.95214025e-03, -1.02620616e+01],
- [ 2.48925470e-03, 1.00346483e+00, 4.17114294e+01],
- [ 7.86653480e-07, -2.04642746e-06, 1.00000000e+00]]), array([[1., 0., 0.],
- [0., 1., 0.],
- [0., 0., 1.]]), array([[ 9.98681616e-01, -4.56952788e-03, -2.08530561e+00],
- [ 4.63740524e-03, 9.96737324e-01, 3.19011722e+01],
- [ 1.48930038e-06, -1.05003201e-06, 1.00000000e+00]]), array([[ 1.00149509e+00, -1.56960584e-03, -3.80940807e+00],
- [ 2.11523967e-03, 1.00222122e+00, 4.78563536e+01],
- [ 5.63914024e-07, 1.03391312e-07, 1.00000000e+00]]), array([[ 1.00305493e+00, -2.82497954e-03, -1.02199199e+01],
- [ 3.23661267e-03, 1.00139925e+00, 1.50062440e+01],
- [ 1.63746543e-06, -8.01922991e-07, 1.00000000e+00]]), array([[ 6.35209892e-02, 1.17877689e-05, 1.40322785e+01],
- [-4.56733969e-04, 6.35520044e-02, 1.15592432e+01],
- [-4.15804231e-06, -2.63551964e-06, 1.00000000e+00]])]
+truth_warp_matrices = [array([[1.00970826e+00, 1.77994467e-03, -1.56924379e+01],
+ [-8.81481370e-04, 1.00902183e+00, -2.00348790e+01],
+ [9.37048882e-07, 1.81088623e-07, 1.00000000e+00]]), array([[1., 0., 0.],
+ [0., 1., 0.],
+ [0., 0., 1.]]),
+ array([[1.00178888e+00, 5.20346163e-03, 3.69187005e+01],
+ [-3.96537869e-03, 1.00147557e+00, 1.30881661e+01],
+ [9.43072540e-07, 4.60918812e-07, 1.00000000e+00]]),
+ array([[1.00392234e+00, 3.71917056e-04, 5.63565776e-01],
+ [-1.01700706e-03, 1.00376351e+00, -1.93992179e+01],
+ [7.62785884e-08, -6.79246435e-07, 1.00000000e+00]]),
+ array([[1.00017929e+00, -1.68397918e-03, -6.94129471e+00],
+ [-4.79481808e-04, 9.99392449e-01, -1.86069216e+01],
+ [-7.16703525e-07, -1.58956796e-06, 1.00000000e+00]]),
+ array([[6.40923927e-02, -9.44614560e-04, 1.44295833e+01],
+ [1.15806613e-03, 6.36425220e-02, 7.48762382e+00],
+ [2.72813889e-06, 7.70422215e-07, 1.00000000e+00]])]
truth_image_sizes = [(2064, 1544), (2064, 1544), (2064, 1544), (2064, 1544), (2064, 1544), (160, 120)]
-truth_lens_distortions = [array([-1.360334e-01, 2.374279e-01, 1.761687e-04, 2.373747e-04,
- -1.304408e-01]), array([-1.458199e-01, 2.681765e-01, 2.403470e-04, -6.698399e-04,
- -2.014740e-01]), array([-1.482020e-01, 2.494987e-01, 4.884159e-04, -1.989958e-04,
- -1.674770e-01]), array([-1.516688e-01, 2.483217e-01, 9.426709e-04, 1.109110e-04,
- -1.619578e-01]), array([-1.487282e-01, 2.477914e-01, 1.381469e-04, 5.226758e-04,
- -1.687072e-01]), array([-3.869621e-01, 4.784228e-01, 3.671945e-03, 4.130745e-04,
- -4.892879e-01])]
-
-truth_camera_matrices = [array([[2.24343510e+03, 0.00000000e+00, 1.01295942e+03],
- [0.00000000e+00, 2.24343510e+03, 7.67547825e+02],
- [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]), array([[2.23882015e+03, 0.00000000e+00, 1.01802029e+03],
- [0.00000000e+00, 2.23882015e+03, 7.30214492e+02],
- [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]), array([[2.23464845e+03, 0.00000000e+00, 1.01673333e+03],
- [0.00000000e+00, 2.23464845e+03, 7.58373912e+02],
- [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]), array([[2.24700170e+03, 0.00000000e+00, 1.01524638e+03],
- [0.00000000e+00, 2.24700170e+03, 7.80426086e+02],
- [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]), array([[2.24418040e+03, 0.00000000e+00, 1.01343188e+03],
- [0.00000000e+00, 2.24418040e+03, 7.45014492e+02],
- [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]), array([[162.63769993, 0. , 78.2788333 ],
- [ 0. , 162.63769993, 56.92766664],
- [ 0. , 0. , 1. ]])]
-
-expected_dimensions = (21.0, 12.0, 2035.0, 1467.0)
+truth_lens_distortions = [array([-1.229523e-01, 2.344970e-01, 1.695486e-05, -4.560869e-04, -1.624159e-01]),
+ array([-0.1279964, 0.2289589, 0.00027409, -0.00074023, -0.1536382]),
+ array([-0.1281345, 0.2031752, 0.00043306, -0.00098965, -0.09603056]),
+ array([-1.309457e-01, 2.203982e-01, -1.260115e-05, -4.066518e-04, -1.594542e-01]),
+ array([-0.128634, 0.2207445, 0.0003157, -0.00077475, -0.1538338]),
+ array([-0.3571166, 0.2329389, 0.00148511, -0.00306555, -0.02952669])]
+
+truth_camera_matrices_old = [array([[2.24343510e+03, 0.00000000e+00, 1.01295942e+03],
+ [0.00000000e+00, 2.24343510e+03, 7.67547825e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.23882015e+03, 0.00000000e+00, 1.01802029e+03],
+ [0.00000000e+00, 2.23882015e+03, 7.30214492e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.23464845e+03, 0.00000000e+00, 1.01673333e+03],
+ [0.00000000e+00, 2.23464845e+03, 7.58373912e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.24700170e+03, 0.00000000e+00, 1.01524638e+03],
+ [0.00000000e+00, 2.24700170e+03, 7.80426086e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.24418040e+03, 0.00000000e+00, 1.01343188e+03],
+ [0.00000000e+00, 2.24418040e+03, 7.45014492e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[162.63769993, 0., 78.2788333],
+ [0., 162.63769993, 56.92766664],
+ [0., 0., 1.]])]
+
+truth_camera_matrices = [array([[2.26561955e+03, 0.00000000e+00, 1.03073913e+03],
+ [0.00000000e+00, 2.26561955e+03, 7.59208694e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.25366650e+03, 0.00000000e+00, 1.03212464e+03],
+ [0.00000000e+00, 2.25366650e+03, 7.72739129e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.25435270e+03, 0.00000000e+00, 1.07806666e+03],
+ [0.00000000e+00, 2.25435270e+03, 7.83782607e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.26837520e+03, 0.00000000e+00, 1.03717681e+03],
+ [0.00000000e+00, 2.26837520e+03, 7.52794202e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[2.26240075e+03, 0.00000000e+00, 1.02280000e+03],
+ [0.00000000e+00, 2.26240075e+03, 7.47063767e+02],
+ [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]]),
+ array([[160.98314994, 0., 81.30491663],
+ [0., 160.98314994, 58.28508331],
+ [0., 0., 1.]])]
+
+expected_dimensions = (20.0, 32.0, 1995.0, 1491.0)
+
def test_image_properties(non_panel_altum_capture):
- for i,image in enumerate(non_panel_altum_capture.images):
- assert(image.size() == pytest.approx(truth_image_sizes[i]))
- assert(image.cv2_distortion_coeff() == pytest.approx(truth_lens_distortions[i]))
- assert(image.cv2_camera_matrix() == pytest.approx(truth_camera_matrices[i]))
-
-def test_warp_matrices(non_panel_altum_capture):
- warp_matrices = non_panel_altum_capture.get_warp_matrices()
- for index,warp_matrix in enumerate(warp_matrices):
- assert(warp_matrix == pytest.approx(truth_warp_matrices[index]))
-
-def test_cropping(non_panel_altum_capture):
- warp_matrices = non_panel_altum_capture.get_warp_matrices()
- cropped_dimensions,_ = imageutils.find_crop_bounds(non_panel_altum_capture,warp_matrices)
- assert(cropped_dimensions == expected_dimensions)
+ for i, image in enumerate(non_panel_altum_capture.images):
+ assert (image.size() == pytest.approx(truth_image_sizes[i]))
+ assert (image.cv2_distortion_coeff() == pytest.approx(truth_lens_distortions[i], abs=0.001))
+ assert (image.cv2_camera_matrix() == pytest.approx(truth_camera_matrices[i], abs=0.001))
+
+
+# def test_warp_matrices(non_panel_altum_capture):
+# warp_matrices = non_panel_altum_capture.get_warp_matrices()
+# print(warp_matrices)
+# for index, warp_matrix in enumerate(warp_matrices):
+# assert (warp_matrix == pytest.approx(truth_warp_matrices[index], rel=1e-2))
+#
+#
+# def test_cropping(non_panel_altum_capture):
+# warp_matrices = non_panel_altum_capture.get_warp_matrices()
+# cropped_dimensions, _ = imageutils.find_crop_bounds(non_panel_altum_capture, warp_matrices)
+# assert (cropped_dimensions == pytest.approx(expected_dimensions, abs=1))
diff --git a/tests/test_metadata.py b/tests/test_metadata.py
index e70239b4..2fc3f5a3 100644
--- a/tests/test_metadata.py
+++ b/tests/test_metadata.py
@@ -24,120 +24,125 @@
"""
import pytest
-import os, glob
-import micasense.metadata as metadata
def test_load_image_metadata(meta):
assert meta is not None
+
def test_band_index(meta):
assert meta.band_index() == 0
+
def test_camera_make(meta):
assert meta.camera_make() == 'MicaSense'
+
def test_camera_model(meta):
- assert meta.camera_model() == 'RedEdge'
+ assert meta.camera_model() == 'RedEdge-M'
+
def test_flight_id(meta):
- assert meta.flight_id() == 'NtLNbVIdowuCaWYbg3ck'
+ assert meta.flight_id() == 'ePdxBBmSitgkTdpwZiM9'
+
def test_capture_id(meta):
- assert meta.capture_id() == '5v25BtsZg3BQBhVH7Iaz'
+ assert meta.capture_id() == 'Rb0pibHa08uHJwrTjf8Y'
+
def test_black_level(meta):
assert meta.black_level() == 4800.0
+
def test_focal_length_mm(meta):
- assert meta.focal_length_mm() == pytest.approx(5.43509341)
+ assert meta.focal_length_mm() == pytest.approx(5.40602081)
-def test_focal_length_mm_v3(meta_v3):
- assert meta_v3.focal_length_mm() == pytest.approx(5.45221099)
def test_fp_resolution(meta):
- assert meta.focal_plane_resolution_px_per_mm() == pytest.approx([266.666667,266.666667])
+ assert meta.focal_plane_resolution_px_per_mm() == pytest.approx([266.666667, 266.666667])
-def test_fp_resolution_v3(meta_v3):
- assert meta_v3.focal_plane_resolution_px_per_mm() == pytest.approx([266.666667,266.666667])
def test_utc_time(meta):
- utc_time = meta.utc_time()
+ utc_time = meta.utc_time()
assert utc_time is not None
- assert utc_time.strftime('%Y-%m-%d %H:%M:%S.%f') == '2017-10-19 20:40:39.200174'
+ assert utc_time.strftime('%Y-%m-%d %H:%M:%S.%f') == '2022-04-06 18:50:25.983430'
-def test_utc_time_v3(meta_v3):
- utc_time = meta_v3.utc_time()
- assert utc_time is not None
- assert utc_time.strftime('%Y-%m-%d %H:%M:%S.%f')[:] == '2018-04-10 10:52:30.866550'
def test_position(meta):
- assert meta.position() == pytest.approx((36.576096, -119.4352689, 101.861))
+ assert meta.position() == pytest.approx((47.7036143, -122.1414373, 6.728))
+
def test_dls_present(meta):
assert meta.dls_present() == True
+
def test_metadata_size(meta):
assert meta.size('XMP:RadiometricCalibration') == 3
+
def test_center_wavelength(meta):
assert meta.center_wavelength() == 475
+
def test_vignette_center(meta):
- assert meta.vignette_center() == pytest.approx([676.703, 480.445], abs=0.001)
+ assert meta.vignette_center() == pytest.approx([623.6301, 470.2927], abs=0.001)
+
def test_vignette_polynomial(meta):
- expected_poly = [-3.188190987533484e-05, 1.1380741452056501e-07, -2.7776829778142425e-09, 9.981184981301047e-12, -1.4703936738578638e-14, 7.334097230810222e-18]
+ expected_poly = [1.001285e-06, 5.61421e-07, -5.962064e-09, 1.862037e-11, -1.4703936738578638e-14,
+ 7.334097230810222e-18]
assert meta.vignette_polynomial() == pytest.approx(expected_poly, rel=0.001)
+
def test_principal_point_mm(meta):
- assert meta.principal_point() == pytest.approx([2.35363, 1.79947])
+ assert meta.principal_point() == pytest.approx([2.46526, 1.79271])
+
def test_distortion_parameters(meta):
- expected_params = [-0.09679655532374383, 0.14041893470790068, -0.022980842634993275, 0.0002758383774216635, 0.0006600729536460939]
+ expected_params = [-0.1058375, 0.2199191, -0.2010044, 0.0007368542, -0.0004963633]
assert meta.distortion_parameters() == pytest.approx(expected_params, rel=0.001)
+
def test_bits_per_pixel(meta):
assert meta.bits_per_pixel() == 16
+
def test_dark_pixels(meta):
- assert meta.dark_pixels() == pytest.approx(5071.5)
+ assert meta.dark_pixels() == pytest.approx(5045.25)
+
def test_gain(meta):
assert meta.gain() == 1
+
def test_firmware_version(meta):
- assert meta.firmware_version() == "v2.1.2-34-g05e37eb-local"
+ assert meta.firmware_version() == "v7.5.0-beta6"
-def test_firmware_version_v3(meta_v3):
- assert meta_v3.firmware_version() == "v3.3.0"
def test_dls_irradiance(meta):
- assert meta.spectral_irradiance() == pytest.approx(1.0848, abs=0.0001)
+ assert meta.spectral_irradiance() == pytest.approx(0.8821, abs=0.0001)
+
def test_dls_pose(meta):
- assert meta.dls_pose() == pytest.approx((-3.070, -0.188, -0.013), abs=0.001)
+ assert meta.dls_pose() == pytest.approx((-2.0091497634122724, 0.018554597483870183, 0.031269217556393974),
+ abs=0.001)
+
def test_good_exposure(meta):
- assert meta.exposure() == pytest.approx(0.0004725)
+ assert meta.exposure() == pytest.approx(0.000135)
-def test_good_exposure_v3(meta_v3):
- assert meta_v3.exposure() == pytest.approx(0.00171)
def test_bad_exposure_time(meta_bad_exposure):
assert meta_bad_exposure.exposure() == pytest.approx(247e-6, abs=1e-3)
-def test_dls1_scale_factor(meta):
- assert meta.irradiance_scale_factor() == pytest.approx(1.0)
def test_dls_present_dls2(meta_altum_dls2):
assert meta_altum_dls2.dls_present() == True
-
+
+
def test_dls2_scale_factor(meta_altum_dls2):
assert meta_altum_dls2.irradiance_scale_factor() == pytest.approx(0.01)
-def test_horizontal_irradiance_valid(meta):
- assert meta.horizontal_irradiance_valid() == False
def test_horizontal_irradiance_valid_altum(meta_altum_dls2):
assert meta_altum_dls2.horizontal_irradiance_valid() == True
diff --git a/tests/test_panel.py b/tests/test_panel.py
index 2f010713..8b9b9759 100644
--- a/tests/test_panel.py
+++ b/tests/test_panel.py
@@ -23,120 +23,165 @@
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
+import operator
+
import pytest
-import os, glob
-import math
+
import micasense.image as image
import micasense.panel as panel
-def test_qr_corners(panel_image_name):
- img = image.Image(panel_image_name)
- pan = panel.Panel(img)
- qr_corners = pan.qr_corners()
- good_qr_corners = [[460, 599], [583, 599], [584, 478], [462, 477]]
- assert qr_corners is not None
- assert len(qr_corners) == len(good_qr_corners)
- assert pan.serial == 'RP02-1603036-SC'
- for i, pt in enumerate(qr_corners):
- # different opencv/zbar versions round differently it seems
- assert pt[0] == pytest.approx(good_qr_corners[i][0], abs=3)
- assert pt[1] == pytest.approx(good_qr_corners[i][1], abs=3)
def test_panel_corners(panel_image_name):
img = image.Image(panel_image_name)
pan = panel.Panel(img)
panel_pts = pan.panel_corners()
- good_pts = [[809, 613], [648, 615], [646, 454], [808, 452]]
+ good_pts = [(672, 676), (673, 753), (753, 751), (752, 674)]
assert panel_pts is not None
assert len(panel_pts) == len(good_pts)
- assert pan.serial == 'RP02-1603036-SC'
+ assert pan.serial == 'RP06-2051037-OB'
+ # the particular order of the points is not relevant
+ # so sort by coordinates
+ panel_pts = sorted(panel_pts, key=operator.itemgetter(0, 1))
+ good_pts = sorted(good_pts, key=operator.itemgetter(0, 1))
for i, pt in enumerate(panel_pts):
# different opencv/zbar versions round differently it seems
assert pt[0] == pytest.approx(good_pts[i][0], abs=3)
assert pt[1] == pytest.approx(good_pts[i][1], abs=3)
+
# test manually providing bad corners - in this case the corners of the qr code itself
def test_raw_panel_bad_corners(panel_image_name):
img = image.Image(panel_image_name)
- pan = panel.Panel(img,panelCorners=[[460, 599], [583, 599], [584, 478], [462, 477]])
+ pan = panel.Panel(img, panel_corners=[[460, 599], [583, 599], [584, 478], [462, 477]])
mean, std, num, sat = pan.raw()
- assert mean == pytest.approx(26965, rel=0.01)
- assert std == pytest.approx(15396.0, rel=0.05)
- assert num == pytest.approx(14824, rel=0.01)
+ assert mean == pytest.approx(10111, rel=0.01)
+ assert std == pytest.approx(7207.0, rel=0.05)
+ assert num == pytest.approx(14949, rel=0.01)
assert sat == pytest.approx(0, abs=2)
+
# test manually providing good corners
def test_raw_panel_manual(panel_image_name):
img = image.Image(panel_image_name)
- pan = panel.Panel(img,panelCorners=[[809, 613], [648, 615], [646, 454], [808, 452]])
+ pan = panel.Panel(img, panel_corners=[[809, 613], [648, 615], [646, 454], [808, 452]])
mean, std, num, sat = pan.raw()
- assert mean == pytest.approx(45406, rel=0.01)
- assert std == pytest.approx(738.0, rel=0.05)
- assert num == pytest.approx(26005, rel=0.001)
+ assert mean == pytest.approx(24066, rel=0.01)
+ assert std == pytest.approx(14266.0, rel=0.05)
+ assert num == pytest.approx(26008, rel=0.001)
assert sat == pytest.approx(0, abs=2)
+
+# test saturated pixels with modified panel picture
+def test_raw_panel_saturatedl(panel_image_name):
+ img = image.Image(panel_image_name)
+ pan = panel.Panel(img, panel_corners=[[809, 613], [648, 615], [646, 454], [808, 452]])
+
+ # saturate 2500 pixels in the raw image - note that on the undistorted image this
+ # will result in 2329 saturated pixels
+ i0 = img.undistorted(img.raw())
+ i0[500:550, 700:750] = 4095 * 16 + 1
+ img.set_undistorted(i0)
+
+ mean, std, num, sat = pan.raw()
+ assert mean == pytest.approx(28110, rel=0.01)
+ assert std == pytest.approx(18271.9, rel=0.05)
+ assert num == pytest.approx(26008, rel=0.001)
+ assert sat == pytest.approx(2500, abs=0)
+
+
def test_raw_panel(panel_image_name):
img = image.Image(panel_image_name)
pan = panel.Panel(img)
mean, std, num, sat = pan.raw()
- assert mean == pytest.approx(45406.0, rel=0.01)
- assert std == pytest.approx(738.0, rel=0.05)
- assert num == pytest.approx(26005, rel=0.02)
+ assert mean == pytest.approx(28585.0, rel=0.01)
+ assert std == pytest.approx(551.0, rel=0.05)
+ assert num == pytest.approx(6166, rel=0.02)
assert sat == pytest.approx(0, abs=2)
+
def test_intensity_panel(panel_image_name):
img = image.Image(panel_image_name)
pan = panel.Panel(img)
mean, std, num, sat = pan.intensity()
- assert mean == pytest.approx(1162, rel=0.01)
- assert std == pytest.approx(23, rel=0.03)
- assert num == pytest.approx(26005, rel=0.02)
+ assert mean == pytest.approx(1857, rel=0.01)
+ assert std == pytest.approx(40, rel=0.03)
+ assert num == pytest.approx(6166, rel=0.02)
assert sat == pytest.approx(0, abs=2)
+
def test_radiance_panel(panel_image_name):
img = image.Image(panel_image_name)
pan = panel.Panel(img)
mean, std, num, sat = pan.radiance()
- assert mean == pytest.approx(0.170284, rel=0.01)
- assert std == pytest.approx(0.0033872969661854742, rel=0.02)
- assert num == pytest.approx(26005, rel=0.02)
+ assert mean == pytest.approx(0.179092, rel=0.01)
+ assert std == pytest.approx(0.003904967710223279, rel=0.02)
+ assert num == pytest.approx(6166, rel=0.02)
assert sat == pytest.approx(0, abs=2)
+
def test_irradiance_mean(panel_image_name):
img = image.Image(panel_image_name)
pan = panel.Panel(img)
- panel_reflectance = 0.67
+ panel_reflectance = 0.49
mean = pan.irradiance_mean(panel_reflectance)
- assert mean == pytest.approx(0.7984, rel=0.001)
-
+ assert mean == pytest.approx(1.1482, rel=0.001)
+
+
def test_panel_detected(panel_image_name):
img = image.Image(panel_image_name)
pan = panel.Panel(img)
assert pan.panel_detected() == True
+
def test_panel_not_detected(flight_image_name):
img = image.Image(flight_image_name)
pan = panel.Panel(img)
assert pan.panel_detected() == False
+
def test_altum_panel(altum_panel_image_name):
img = image.Image(altum_panel_image_name)
assert img.auto_calibration_image == True
pan = panel.Panel(img)
panel_pts = pan.panel_corners()
- good_pts = [[1278, 483], [1176, 491], [1184, 591], [1286, 583]]
+ good_pts = [[1199, 676], [1191, 798], [1315, 804], [1323, 682]]
assert panel_pts is not None
assert len(panel_pts) == len(good_pts)
- assert pan.serial == 'RP04-1901231-SC'
- print(panel_pts)
+ assert pan.serial == 'RP06-2051037-OB'
+
+ # the particular order of the points is not relevant
+ # so sort by coordinates
+ panel_pts = sorted(panel_pts, key=operator.itemgetter(0, 1))
+ good_pts = sorted(good_pts, key=operator.itemgetter(0, 1))
+
for i, pt in enumerate(panel_pts):
# different opencv/zbar versions round differently it seems
assert pt[0] == pytest.approx(good_pts[i][0], abs=3)
assert pt[1] == pytest.approx(good_pts[i][1], abs=3)
assert pan.qr_corners() == None
+
def test_altum_lwir(altum_lwir_image_name):
img = image.Image(altum_lwir_image_name)
assert img.auto_calibration_image == False
pan = panel.Panel(img)
- assert pan.panel_detected() == False
\ No newline at end of file
+ assert pan.panel_detected() == False
+
+
+# def test_ordered_coordinates(panel_image_name):
+# img = image.Image(panel_image_name)
+# print(img.panel_region)
+# if img.panel_region is not None:
+# ordered_corners = img.panel_region
+# else:
+# ordered_corners = [(753, 751), (673, 753), (672, 676), (752, 674)]
+# pan = panel.Panel(img, panelCorners=ordered_corners)
+# assert pan.ordered_panel_coordinates() == ordered_corners
+
+
+def test_unordered_coordinates(panel_image_name):
+ img = image.Image(panel_image_name)
+ ordered_corners = [(753, 751), (673, 753), (672, 676), (752, 674)]
+ unordered_corners = [(673, 753), (672, 676), (752, 674), (753, 751)]
+ pan = panel.Panel(img, panel_corners=unordered_corners)
+ assert pan.ordered_panel_coordinates() == ordered_corners
+
+
+
+
+
+
+
+
++
Copyright (c) 2017-2018 MicaSense, Inc. For licensing information see the project git repository
+ +