def test_plantcv_flip():
img = cv2.imread(os.path.join(TEST_DATA, TEST_INPUT_COLOR))
device, flipped_img = pcv.flip(img=img,
direction="horizontal",
device=0,
debug=None)
assert all([i == j] for i, j in zip(np.shape(flipped_img), TEST_COLOR_DIM))
def main():
# Get options
args = options()
# Read image
img, path, filename = pcv.readimage(args.image)
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, 's', device, args.debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 36, 255, 'light', device, args.debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 0, device, args.debug)
device, s_cnt = pcv.median_blur(s_thresh, 0, device, args.debug)
# Fill small objects
#device, s_fill = pcv.fill(s_mblur, s_cnt, 0, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, 'b', device, args.debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 137, 255, 'light', device, args.debug)
device, b_cnt = pcv.binary_threshold(b, 137, 255, 'light', device, args.debug)
# Fill small objects
#device, b_fill = pcv.fill(b_thresh, b_cnt, 10, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_mblur, b_cnt, device, args.debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, 'white', device, args.debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked_a = pcv.rgb2gray_lab(masked, 'a', device, args.debug)
device, masked_b = pcv.rgb2gray_lab(masked, 'b', device, args.debug)
# Threshold the green-magenta and blue images
device, maskeda_thresh = pcv.binary_threshold(masked_a, 127, 255, 'dark', device, args.debug)
device, maskedb_thresh = pcv.binary_threshold(masked_b, 128, 255, 'light', device, args.debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, ab = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, args.debug)
device, ab_cnt = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, args.debug)
# Fill small noise
device, ab_fill1 = pcv.fill(ab, ab_cnt, 2, device, args.debug)
# Dilate to join small objects with larger ones
device, ab_cnt1=pcv.dilate(ab_fill1, 3, 2, device, args.debug)
device, ab_cnt2=pcv.dilate(ab_fill1, 3, 2, device, args.debug)
# Fill dilated image mask
device, ab_cnt3=pcv.fill(ab_cnt2,ab_cnt1,150,device,args.debug)
device, masked2 = pcv.apply_mask(masked, ab_cnt3, 'white', device, args.debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked2_a = pcv.rgb2gray_lab(masked2, 'a', device, args.debug)
device, masked2_b = pcv.rgb2gray_lab(masked2, 'b', device, args.debug)
# Threshold the green-magenta and blue images
device, masked2a_thresh = pcv.binary_threshold(masked2_a, 127, 255, 'dark', device, args.debug)
device, masked2b_thresh = pcv.binary_threshold(masked2_b, 128, 255, 'light', device, args.debug)
device, ab_fill = pcv.logical_or(masked2a_thresh, masked2b_thresh, device, args.debug)
# Identify objects
device, id_objects,obj_hierarchy = pcv.find_objects(masked2, ab_fill, device, args.debug)
# Define ROI
device, roi1, roi_hierarchy= pcv.define_roi(masked2,'rectangle', device, None, 'default', args.debug,True, 550, 0,-600,-907)
# Decide which objects to keep
device,roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img,'partial',roi1,roi_hierarchy,id_objects,obj_hierarchy,device, args.debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3, device, args.debug)
############## VIS Analysis ################
outfile=False
if args.writeimg==True:
outfile=args.outdir+"/"+filename
# Find shape properties, output shape image (optional)
device, shape_header,shape_data,shape_img = pcv.analyze_object(img, args.image, obj, mask, device,args.debug,outfile)
# Shape properties relative to user boundary line (optional)
device, boundary_header,boundary_data, boundary_img1= pcv.analyze_bound(img, args.image,obj, mask, 935, device,args.debug,outfile)
# Determine color properties: Histograms, Color Slices and Pseudocolored Images, output color analyzed images (optional)
device, color_header,color_data,color_img= pcv.analyze_color(img, args.image, mask, 256, device, args.debug,None,'v','img',300,outfile)
# Output shape and color data
result=open(args.result,"a")
result.write('\t'.join(map(str,shape_header)))
result.write("\n")
result.write('\t'.join(map(str,shape_data)))
result.write("\n")
for row in shape_img:
result.write('\t'.join(map(str,row)))
result.write("\n")
result.write('\t'.join(map(str,color_header)))
result.write("\n")
result.write('\t'.join(map(str,color_data)))
result.write("\n")
result.write('\t'.join(map(str,boundary_header)))
result.write("\n")
result.write('\t'.join(map(str,boundary_data)))
result.write("\n")
result.write('\t'.join(map(str,boundary_img1)))
result.write("\n")
for row in color_img:
result.write('\t'.join(map(str,row)))
result.write("\n")
result.close()
############################# Use VIS image mask for NIR image#########################
# Find matching NIR image
device, nirpath=pcv.get_nir(path,filename,device,args.debug)
nir, path1, filename1=pcv.readimage(nirpath)
nir2=cv2.imread(nirpath,-1)
# Flip mask
device, f_mask= pcv.flip(mask,"vertical",device,args.debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.118069,0.118069, device, args.debug)
# position, and crop mask
device,newmask=pcv.crop_position_mask(nir,nmask,device,40,3,"top","right",args.debug)
# Identify objects
device, nir_objects,nir_hierarchy = pcv.find_objects(nir, newmask, device, args.debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir, nir_objects, nir_hierarchy, device, args.debug)
####################################### Analysis #############################################
outfile1=False
if args.writeimg==True:
outfile1=args.outdir+"/"+filename1
device,nhist_header, nhist_data,nir_imgs= pcv.analyze_NIR_intensity(nir2, filename1, nir_combinedmask, 256, device,False, args.debug, outfile1)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir2, filename1, nir_combined, nir_combinedmask, device, args.debug, outfile1)
coresult=open(args.coresult,"a")
coresult.write('\t'.join(map(str,nhist_header)))
coresult.write("\n")
coresult.write('\t'.join(map(str,nhist_data)))
coresult.write("\n")
for row in nir_imgs:
coresult.write('\t'.join(map(str,row)))
coresult.write("\n")
coresult.write('\t'.join(map(str,nshape_header)))
coresult.write("\n")
coresult.write('\t'.join(map(str,nshape_data)))
coresult.write("\n")
coresult.write('\t'.join(map(str,nir_shape)))
coresult.write("\n")
coresult.close()
def main():
# Get options
args = options()
# Read image
img, path, filename = pcv.readimage(args.image)
brass_mask = cv2.imread(args.roi)
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, "s", device, args.debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 49, 255, "light", device, args.debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, args.debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, args.debug)
# Fill small objects
device, s_fill = pcv.fill(s_mblur, s_cnt, 150, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, "b", device, args.debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 138, 255, "light", device, args.debug)
device, b_cnt = pcv.binary_threshold(b, 138, 255, "light", device, args.debug)
# Fill small objects
device, b_fill = pcv.fill(b_thresh, b_cnt, 150, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_fill, b_fill, device, args.debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, "white", device, args.debug)
# Mask pesky brass piece
device, brass_mask1 = pcv.rgb2gray_hsv(brass_mask, "v", device, args.debug)
device, brass_thresh = pcv.binary_threshold(brass_mask1, 0, 255, "light", device, args.debug)
device, brass_inv = pcv.invert(brass_thresh, device, args.debug)
device, brass_masked = pcv.apply_mask(masked, brass_inv, "white", device, args.debug)
# Further mask soil and car
device, masked_a = pcv.rgb2gray_lab(brass_masked, "a", device, args.debug)
device, soil_car = pcv.binary_threshold(masked_a, 128, 255, "dark", device, args.debug)
device, soil_masked = pcv.apply_mask(brass_masked, soil_car, "white", device, args.debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, soil_a = pcv.rgb2gray_lab(soil_masked, "a", device, args.debug)
device, soil_b = pcv.rgb2gray_lab(soil_masked, "b", device, args.debug)
# Threshold the green-magenta and blue images
device, soila_thresh = pcv.binary_threshold(soil_a, 118, 255, "dark", device, args.debug)
device, soilb_thresh = pcv.binary_threshold(soil_b, 150, 255, "light", device, args.debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, soil_ab = pcv.logical_or(soila_thresh, soilb_thresh, device, args.debug)
device, soil_ab_cnt = pcv.logical_or(soila_thresh, soilb_thresh, device, args.debug)
# Fill small objects
device, soil_cnt = pcv.fill(soil_ab, soil_ab_cnt, 75, device, args.debug)
# Median Filter
# device, soil_mblur = pcv.median_blur(soil_fill, 5, device, args.debug)
# device, soil_cnt = pcv.median_blur(soil_fill, 5, device, args.debug)
# Apply mask (for vis images, mask_color=white)
device, masked2 = pcv.apply_mask(soil_masked, soil_cnt, "white", device, args.debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, soil_cnt, device, args.debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(
img, "circle", device, None, "default", args.debug, True, 0, 0, -200, -200
)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img, "partial", roi1, roi_hierarchy, id_objects, obj_hierarchy, device, args.debug
)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3, device, args.debug)
############## VIS Analysis ################
outfile = False
if args.writeimg == True:
outfile = args.outdir + "/" + filename
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(
img, args.image, obj, mask, device, args.debug, outfile
)
# Determine color properties: Histograms, Color Slices and Pseudocolored Images, output color analyzed images (optional)
device, color_header, color_data, color_img = pcv.analyze_color(
img, args.image, mask, 256, device, args.debug, None, "v", "img", 300, outfile
)
# Output shape and color data
result = open(args.result, "a")
result.write("\t".join(map(str, shape_header)))
result.write("\n")
result.write("\t".join(map(str, shape_data)))
result.write("\n")
for row in shape_img:
result.write("\t".join(map(str, row)))
result.write("\n")
result.write("\t".join(map(str, color_header)))
result.write("\n")
result.write("\t".join(map(str, color_data)))
result.write("\n")
for row in color_img:
result.write("\t".join(map(str, row)))
result.write("\n")
result.close()
############################# Use VIS image mask for NIR image#########################
# Find matching NIR image
device, nirpath = pcv.get_nir(path, filename, device, args.debug)
nir, path1, filename1 = pcv.readimage(nirpath)
nir2 = cv2.imread(nirpath, -1)
# Flip mask
device, f_mask = pcv.flip(mask, "horizontal", device, args.debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.1304, 0.1304, device, args.debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir, nmask, device, 9, 12, "top", "left", args.debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir, newmask, device, args.debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir, nir_objects, nir_hierarchy, device, args.debug)
####################################### Analysis #############################################
outfile1 = False
if args.writeimg == True:
outfile1 = args.outdir + "/" + filename1
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(
nir2, filename1, nir_combinedmask, 256, device, False, args.debug, outfile1
)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(
nir2, filename1, nir_combined, nir_combinedmask, device, args.debug, outfile1
)
coresult = open(args.coresult, "a")
coresult.write("\t".join(map(str, nhist_header)))
coresult.write("\n")
coresult.write("\t".join(map(str, nhist_data)))
coresult.write("\n")
for row in nir_imgs:
coresult.write("\t".join(map(str, row)))
coresult.write("\n")
coresult.write("\t".join(map(str, nshape_header)))
coresult.write("\n")
coresult.write("\t".join(map(str, nshape_data)))
coresult.write("\n")
coresult.write("\t".join(map(str, nir_shape)))
coresult.write("\n")
coresult.close()
def main():
# Get options
args = options()
# Read image
img, path, filename = pcv.readimage(args.image)
brass_mask = cv2.imread(args.roi)
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, 's', device, args.debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 49, 255, 'light', device,
args.debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, args.debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, args.debug)
# Fill small objects
device, s_fill = pcv.fill(s_mblur, s_cnt, 150, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, 'b', device, args.debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 138, 255, 'light', device,
args.debug)
device, b_cnt = pcv.binary_threshold(b, 138, 255, 'light', device,
args.debug)
# Fill small objects
device, b_fill = pcv.fill(b_thresh, b_cnt, 100, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_fill, b_fill, device, args.debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, 'white', device, args.debug)
# Mask pesky brass piece
device, brass_mask1 = pcv.rgb2gray_hsv(brass_mask, 'v', device, args.debug)
device, brass_thresh = pcv.binary_threshold(brass_mask1, 0, 255, 'light',
device, args.debug)
device, brass_inv = pcv.invert(brass_thresh, device, args.debug)
device, brass_masked = pcv.apply_mask(masked, brass_inv, 'white', device,
args.debug)
# Further mask soil and car
device, masked_a = pcv.rgb2gray_lab(brass_masked, 'a', device, args.debug)
device, soil_car1 = pcv.binary_threshold(masked_a, 128, 255, 'dark',
device, args.debug)
device, soil_car2 = pcv.binary_threshold(masked_a, 128, 255, 'light',
device, args.debug)
device, soil_car = pcv.logical_or(soil_car1, soil_car2, device, args.debug)
device, soil_masked = pcv.apply_mask(brass_masked, soil_car, 'white',
device, args.debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, soil_a = pcv.rgb2gray_lab(soil_masked, 'a', device, args.debug)
device, soil_b = pcv.rgb2gray_lab(soil_masked, 'b', device, args.debug)
# Threshold the green-magenta and blue images
device, soila_thresh = pcv.binary_threshold(soil_a, 124, 255, 'dark',
device, args.debug)
device, soilb_thresh = pcv.binary_threshold(soil_b, 148, 255, 'light',
device, args.debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, soil_ab = pcv.logical_or(soila_thresh, soilb_thresh, device,
args.debug)
device, soil_ab_cnt = pcv.logical_or(soila_thresh, soilb_thresh, device,
args.debug)
# Fill small objects
device, soil_cnt = pcv.fill(soil_ab, soil_ab_cnt, 150, device, args.debug)
# Median Filter
#device, soil_mblur = pcv.median_blur(soil_fill, 5, device, args.debug)
#device, soil_cnt = pcv.median_blur(soil_fill, 5, device, args.debug)
# Apply mask (for vis images, mask_color=white)
device, masked2 = pcv.apply_mask(soil_masked, soil_cnt, 'white', device,
args.debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(
masked2, soil_cnt, device, args.debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(img, 'rectangle', device,
None, 'default', args.debug,
True, 600, 450, -600, -350)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img, 'partial', roi1, roi_hierarchy, id_objects, obj_hierarchy, device,
args.debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3,
device, args.debug)
############## VIS Analysis ################
outfile = False
if args.writeimg == True:
outfile = args.outdir + "/" + filename
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(
img, args.image, obj, mask, device, args.debug, outfile)
# Determine color properties: Histograms, Color Slices and Pseudocolored Images, output color analyzed images (optional)
device, color_header, color_data, color_img = pcv.analyze_color(
img, args.image, mask, 256, device, args.debug, None, 'v', 'img', 300,
outfile)
# Output shape and color data
result = open(args.result, "a")
result.write('\t'.join(map(str, shape_header)))
result.write("\n")
result.write('\t'.join(map(str, shape_data)))
result.write("\n")
for row in shape_img:
result.write('\t'.join(map(str, row)))
result.write("\n")
result.write('\t'.join(map(str, color_header)))
result.write("\n")
result.write('\t'.join(map(str, color_data)))
result.write("\n")
for row in color_img:
result.write('\t'.join(map(str, row)))
result.write("\n")
result.close()
############################# Use VIS image mask for NIR image#########################
# Find matching NIR image
device, nirpath = pcv.get_nir(path, filename, device, args.debug)
nir, path1, filename1 = pcv.readimage(nirpath)
nir2 = cv2.imread(nirpath, -1)
# Flip mask
device, f_mask = pcv.flip(mask, "horizontal", device, args.debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.116148, 0.116148, device, args.debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir, nmask, device, 15, 5, "top",
"right", args.debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(
nir, newmask, device, args.debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(
nir, nir_objects, nir_hierarchy, device, args.debug)
####################################### Analysis #############################################
outfile1 = False
if args.writeimg == True:
outfile1 = args.outdir + "/" + filename1
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(
nir2, filename1, nir_combinedmask, 256, device, False, args.debug,
outfile1)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(
nir2, filename1, nir_combined, nir_combinedmask, device, args.debug,
outfile1)
coresult = open(args.coresult, "a")
coresult.write('\t'.join(map(str, nhist_header)))
coresult.write("\n")
coresult.write('\t'.join(map(str, nhist_data)))
coresult.write("\n")
for row in nir_imgs:
coresult.write('\t'.join(map(str, row)))
coresult.write("\n")
coresult.write('\t'.join(map(str, nshape_header)))
coresult.write("\n")
coresult.write('\t'.join(map(str, nshape_data)))
coresult.write("\n")
coresult.write('\t'.join(map(str, nir_shape)))
coresult.write("\n")
coresult.close()
def process_sv_images_core(vis_id, vis_img, nir_id, nir_rgb, nir_cv2, traits, debug=None):
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(vis_img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 36, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
# device, s_fill = pcv.fill(s_mblur, s_cnt, 0, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(vis_img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
device, b_cnt = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
# Fill small objects
# device, b_fill = pcv.fill(b_thresh, b_cnt, 10, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_mblur, b_cnt, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(vis_img, bs, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked_a = pcv.rgb2gray_lab(masked, 'a', device, debug)
device, masked_b = pcv.rgb2gray_lab(masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, maskeda_thresh = pcv.binary_threshold(masked_a, 127, 255, 'dark', device, debug)
device, maskedb_thresh = pcv.binary_threshold(masked_b, 128, 255, 'light', device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, ab = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
device, ab_cnt = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
# Fill small noise
device, ab_fill1 = pcv.fill(ab, ab_cnt, 200, device, debug)
# Dilate to join small objects with larger ones
device, ab_cnt1 = pcv.dilate(ab_fill1, 3, 2, device, debug)
device, ab_cnt2 = pcv.dilate(ab_fill1, 3, 2, device, debug)
# Fill dilated image mask
device, ab_cnt3 = pcv.fill(ab_cnt2, ab_cnt1, 150, device, debug)
device, masked2 = pcv.apply_mask(masked, ab_cnt3, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked2_a = pcv.rgb2gray_lab(masked2, 'a', device, debug)
device, masked2_b = pcv.rgb2gray_lab(masked2, 'b', device, debug)
# Threshold the green-magenta and blue images
device, masked2a_thresh = pcv.binary_threshold(masked2_a, 127, 255, 'dark', device, debug)
device, masked2b_thresh = pcv.binary_threshold(masked2_b, 128, 255, 'light', device, debug)
device, masked2a_thresh_blur = pcv.median_blur(masked2a_thresh, 5, device, debug)
device, masked2b_thresh_blur = pcv.median_blur(masked2b_thresh, 13, device, debug)
device, ab_fill = pcv.logical_or(masked2a_thresh_blur, masked2b_thresh_blur, device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, ab_fill, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(masked2, 'rectangle', device, None, 'default', debug, True, 700,
0, -600, -300)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(vis_img, 'partial', roi1, roi_hierarchy,
id_objects, obj_hierarchy, device,
debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(vis_img, roi_objects, hierarchy3, device, debug)
############## VIS Analysis ################
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(vis_img, vis_id, obj, mask, device, debug)
# Shape properties relative to user boundary line (optional)
device, boundary_header, boundary_data, boundary_img1 = pcv.analyze_bound(vis_img, vis_id, obj, mask, 384, device,
debug)
# Determine color properties: Histograms, Color Slices and
# Pseudocolored Images, output color analyzed images (optional)
device, color_header, color_data, color_img = pcv.analyze_color(vis_img, vis_id, mask, 256, device, debug,
None, 'v', 'img', 300)
# Output shape and color data
vis_traits = {}
for i in range(1, len(shape_header)):
vis_traits[shape_header[i]] = shape_data[i]
for i in range(1, len(boundary_header)):
vis_traits[boundary_header[i]] = boundary_data[i]
for i in range(2, len(color_header)):
vis_traits[color_header[i]] = serialize_color_data(color_data[i])
############################# Use VIS image mask for NIR image#########################
# Flip mask
device, f_mask = pcv.flip(mask, "vertical", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.1154905775, 0.1154905775, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir_rgb, nmask, device, 30, 4, "top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir_rgb, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir_rgb, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(nir_cv2, nir_id, nir_combinedmask, 256,
device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir_cv2, nir_id, nir_combined, nir_combinedmask,
device, debug)
nir_traits = {}
for i in range(1, len(nshape_header)):
nir_traits[nshape_header[i]] = nshape_data[i]
for i in range(2, len(nhist_header)):
nir_traits[nhist_header[i]] = serialize_color_data(nhist_data[i])
# Add data to traits table
traits['sv_area'].append(vis_traits['area'])
traits['hull_area'].append(vis_traits['hull-area'])
traits['solidity'].append(vis_traits['solidity'])
traits['height'].append(vis_traits['height_above_bound'])
traits['perimeter'].append(vis_traits['perimeter'])
return [vis_traits, nir_traits]
def process_tv_images_core(vis_id, vis_img, nir_id, nir_rgb, nir_cv2, brass_mask, traits, debug=None):
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(vis_img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 75, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
device, s_fill = pcv.fill(s_mblur, s_cnt, 150, device, debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(vis_img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
device, b_cnt = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
# Fill small objects
device, b_fill = pcv.fill(b_thresh, b_cnt, 100, device, debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_fill, b_fill, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(vis_img, bs, 'white', device, debug)
# Mask pesky brass piece
device, brass_mask1 = pcv.rgb2gray_hsv(brass_mask, 'v', device, debug)
device, brass_thresh = pcv.binary_threshold(brass_mask1, 0, 255, 'light', device, debug)
device, brass_inv = pcv.invert(brass_thresh, device, debug)
device, brass_masked = pcv.apply_mask(masked, brass_inv, 'white', device, debug)
# Further mask soil and car
device, masked_a = pcv.rgb2gray_lab(brass_masked, 'a', device, debug)
device, soil_car1 = pcv.binary_threshold(masked_a, 128, 255, 'dark', device, debug)
device, soil_car2 = pcv.binary_threshold(masked_a, 128, 255, 'light', device, debug)
device, soil_car = pcv.logical_or(soil_car1, soil_car2, device, debug)
device, soil_masked = pcv.apply_mask(brass_masked, soil_car, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, soil_a = pcv.rgb2gray_lab(soil_masked, 'a', device, debug)
device, soil_b = pcv.rgb2gray_lab(soil_masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, soila_thresh = pcv.binary_threshold(soil_a, 124, 255, 'dark', device, debug)
device, soilb_thresh = pcv.binary_threshold(soil_b, 148, 255, 'light', device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, soil_ab = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
device, soil_ab_cnt = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
# Fill small objects
device, soil_cnt = pcv.fill(soil_ab, soil_ab_cnt, 300, device, debug)
# Apply mask (for vis images, mask_color=white)
device, masked2 = pcv.apply_mask(soil_masked, soil_cnt, 'white', device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, soil_cnt, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(vis_img, 'rectangle', device, None, 'default', debug, True, 600, 450, -600,
-350)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(vis_img, 'partial', roi1, roi_hierarchy,
id_objects, obj_hierarchy, device, debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(vis_img, roi_objects, hierarchy3, device, debug)
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(vis_img, vis_id, obj, mask, device, debug)
# Determine color properties
device, color_header, color_data, color_img = pcv.analyze_color(vis_img, vis_id, mask, 256, device, debug, None,
'v', 'img', 300)
# Output shape and color data
vis_traits = {}
for i in range(1, len(shape_header)):
vis_traits[shape_header[i]] = shape_data[i]
for i in range(2, len(color_header)):
vis_traits[color_header[i]] = serialize_color_data(color_data[i])
############################# Use VIS image mask for NIR image#########################
# Flip mask
device, f_mask = pcv.flip(mask, "horizontal", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.116148, 0.116148, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir_rgb, nmask, device, 15, 5, "top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir_rgb, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir_rgb, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(nir_cv2, nir_id, nir_combinedmask, 256,
device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir_cv2, nir_id, nir_combined, nir_combinedmask,
device, debug)
nir_traits = {}
for i in range(1, len(nshape_header)):
nir_traits[nshape_header[i]] = nshape_data[i]
for i in range(2, len(nhist_header)):
nir_traits[nhist_header[i]] = serialize_color_data(nhist_data[i])
# Add data to traits table
traits['tv_area'] = vis_traits['area']
return [vis_traits, nir_traits]
def process_sv_images(session, url, vis_id, nir_id, traits, debug=None):
"""Process side-view images from Clowder.
Inputs:
session = requests session object
url = Clowder URL
vis_id = The Clowder ID of an RGB image
nir_img = The Clowder ID of an NIR grayscale image
traits = traits table (dictionary)
debug = None, print, or plot. Print = save to file, Plot = print to screen
:param session: requests session object
:param url: str
:param vis_id: str
:param nir_id: str
:param traits: dict
:param debug: str
:return traits: dict
"""
# Read VIS image from Clowder
vis_r = session.get(posixpath.join(url, "api/files", vis_id), stream=True)
img_array = np.asarray(bytearray(vis_r.content), dtype="uint8")
img = cv2.imdecode(img_array, -1)
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 36, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
# device, s_fill = pcv.fill(s_mblur, s_cnt, 0, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
device, b_cnt = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
# Fill small objects
# device, b_fill = pcv.fill(b_thresh, b_cnt, 10, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_mblur, b_cnt, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked_a = pcv.rgb2gray_lab(masked, 'a', device, debug)
device, masked_b = pcv.rgb2gray_lab(masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, maskeda_thresh = pcv.binary_threshold(masked_a, 127, 255, 'dark', device, debug)
device, maskedb_thresh = pcv.binary_threshold(masked_b, 128, 255, 'light', device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, ab = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
device, ab_cnt = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
# Fill small noise
device, ab_fill1 = pcv.fill(ab, ab_cnt, 200, device, debug)
# Dilate to join small objects with larger ones
device, ab_cnt1 = pcv.dilate(ab_fill1, 3, 2, device, debug)
device, ab_cnt2 = pcv.dilate(ab_fill1, 3, 2, device, debug)
# Fill dilated image mask
device, ab_cnt3 = pcv.fill(ab_cnt2, ab_cnt1, 150, device, debug)
device, masked2 = pcv.apply_mask(masked, ab_cnt3, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked2_a = pcv.rgb2gray_lab(masked2, 'a', device, debug)
device, masked2_b = pcv.rgb2gray_lab(masked2, 'b', device, debug)
# Threshold the green-magenta and blue images
device, masked2a_thresh = pcv.binary_threshold(masked2_a, 127, 255, 'dark', device, debug)
device, masked2b_thresh = pcv.binary_threshold(masked2_b, 128, 255, 'light', device, debug)
device, masked2a_thresh_blur = pcv.median_blur(masked2a_thresh, 5, device, debug)
device, masked2b_thresh_blur = pcv.median_blur(masked2b_thresh, 13, device, debug)
device, ab_fill = pcv.logical_or(masked2a_thresh_blur, masked2b_thresh_blur, device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, ab_fill, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(masked2, 'rectangle', device, None, 'default', debug, True, 700,
0, -600, -300)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img, 'partial', roi1, roi_hierarchy,
id_objects, obj_hierarchy, device,
debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3, device, debug)
############## VIS Analysis ################
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(img, vis_id, obj, mask, device, debug)
# Shape properties relative to user boundary line (optional)
device, boundary_header, boundary_data, boundary_img1 = pcv.analyze_bound(img, vis_id, obj, mask, 384, device,
debug)
# Determine color properties: Histograms, Color Slices and
# Pseudocolored Images, output color analyzed images (optional)
device, color_header, color_data, color_img = pcv.analyze_color(img, vis_id, mask, 256, device, debug,
None, 'v', 'img', 300)
# Output shape and color data
vis_traits = {}
for i in range(1, len(shape_header)):
vis_traits[shape_header[i]] = shape_data[i]
for i in range(1, len(boundary_header)):
vis_traits[boundary_header[i]] = boundary_data[i]
for i in range(2, len(color_header)):
vis_traits[color_header[i]] = serialize_color_data(color_data[i])
#print(vis_traits)
add_plantcv_metadata(session, url, vis_id, vis_traits)
############################# Use VIS image mask for NIR image#########################
# Read NIR image from Clowder
nir_r = session.get(posixpath.join(url, "api/files", nir_id), stream=True)
nir_array = np.asarray(bytearray(nir_r.content), dtype="uint8")
nir = cv2.imdecode(nir_array, -1)
nir_rgb = cv2.cvtColor(nir, cv2.COLOR_GRAY2BGR)
# Flip mask
device, f_mask = pcv.flip(mask, "vertical", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.1154905775, 0.1154905775, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir_rgb, nmask, device, 30, 4, "top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir_rgb, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir_rgb, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(nir, nir_id, nir_combinedmask, 256,
device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir, nir_id, nir_combined, nir_combinedmask,
device, debug)
nir_traits = {}
for i in range(1, len(nshape_header)):
nir_traits[nshape_header[i]] = nshape_data[i]
for i in range(2, len(nhist_header)):
nir_traits[nhist_header[i]] = serialize_color_data(nhist_data[i])
#print(nir_traits)
add_plantcv_metadata(session, url, nir_id, nir_traits)
# Add data to traits table
traits['sv_area'].append(vis_traits['area'])
traits['hull_area'].append(vis_traits['hull-area'])
traits['solidity'].append(vis_traits['solidity'])
traits['height'].append(vis_traits['height_above_bound'])
traits['perimeter'].append(vis_traits['perimeter'])
return traits
def process_tv_images(session, url, vis_id, nir_id, traits, debug=False):
"""Process top-view images.
Inputs:
session = requests session object
url = Clowder URL
vis_id = The Clowder ID of an RGB image
nir_img = The Clowder ID of an NIR grayscale image
traits = traits table (dictionary)
debug = None, print, or plot. Print = save to file, Plot = print to screen.
:param session: requests session object
:param url: str
:param vis_id: str
:param nir_id: str
:param traits: dict
:param debug: str
:return traits: dict
"""
# Read VIS image from Clowder
vis_r = session.get(posixpath.join(url, "api/files", vis_id), stream=True)
img_array = np.asarray(bytearray(vis_r.content), dtype="uint8")
img = cv2.imdecode(img_array, -1)
# Read the VIS top-view image mask for zoom = 1 from Clowder
mask_r = session.get(posixpath.join(url, "api/files/57451b28e4b0efbe2dc3d4d5"), stream=True)
mask_array = np.asarray(bytearray(mask_r.content), dtype="uint8")
brass_mask = cv2.imdecode(mask_array, -1)
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 75, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
device, s_fill = pcv.fill(s_mblur, s_cnt, 150, device, debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
device, b_cnt = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
# Fill small objects
device, b_fill = pcv.fill(b_thresh, b_cnt, 100, device, debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_fill, b_fill, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, 'white', device, debug)
# Mask pesky brass piece
device, brass_mask1 = pcv.rgb2gray_hsv(brass_mask, 'v', device, debug)
device, brass_thresh = pcv.binary_threshold(brass_mask1, 0, 255, 'light', device, debug)
device, brass_inv = pcv.invert(brass_thresh, device, debug)
device, brass_masked = pcv.apply_mask(masked, brass_inv, 'white', device, debug)
# Further mask soil and car
device, masked_a = pcv.rgb2gray_lab(brass_masked, 'a', device, debug)
device, soil_car1 = pcv.binary_threshold(masked_a, 128, 255, 'dark', device, debug)
device, soil_car2 = pcv.binary_threshold(masked_a, 128, 255, 'light', device, debug)
device, soil_car = pcv.logical_or(soil_car1, soil_car2, device, debug)
device, soil_masked = pcv.apply_mask(brass_masked, soil_car, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, soil_a = pcv.rgb2gray_lab(soil_masked, 'a', device, debug)
device, soil_b = pcv.rgb2gray_lab(soil_masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, soila_thresh = pcv.binary_threshold(soil_a, 124, 255, 'dark', device, debug)
device, soilb_thresh = pcv.binary_threshold(soil_b, 148, 255, 'light', device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, soil_ab = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
device, soil_ab_cnt = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
# Fill small objects
device, soil_cnt = pcv.fill(soil_ab, soil_ab_cnt, 300, device, debug)
# Apply mask (for vis images, mask_color=white)
device, masked2 = pcv.apply_mask(soil_masked, soil_cnt, 'white', device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, soil_cnt, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(img, 'rectangle', device, None, 'default', debug, True, 600, 450, -600,
-350)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img, 'partial', roi1, roi_hierarchy,
id_objects, obj_hierarchy, device, debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3, device, debug)
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(img, vis_id, obj, mask, device, debug)
# Determine color properties
device, color_header, color_data, color_img = pcv.analyze_color(img, vis_id, mask, 256, device, debug, None,
'v', 'img', 300)
# Output shape and color data
vis_traits = {}
for i in range(1, len(shape_header)):
vis_traits[shape_header[i]] = shape_data[i]
for i in range(2, len(color_header)):
vis_traits[color_header[i]] = serialize_color_data(color_data[i])
#print(vis_traits)
add_plantcv_metadata(session, url, vis_id, vis_traits)
############################# Use VIS image mask for NIR image#########################
# Read NIR image from Clowder
nir_r = session.get(posixpath.join(url, "api/files", nir_id), stream=True)
nir_array = np.asarray(bytearray(nir_r.content), dtype="uint8")
nir = cv2.imdecode(nir_array, -1)
nir_rgb = cv2.cvtColor(nir, cv2.COLOR_GRAY2BGR)
# Flip mask
device, f_mask = pcv.flip(mask, "horizontal", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.116148, 0.116148, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir_rgb, nmask, device, 15, 5, "top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir_rgb, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir_rgb, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(nir, nir_id, nir_combinedmask, 256,
device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir, nir_id, nir_combined, nir_combinedmask,
device, debug)
nir_traits = {}
for i in range(1, len(nshape_header)):
nir_traits[nshape_header[i]] = nshape_data[i]
for i in range(2, len(nhist_header)):
nir_traits[nhist_header[i]] = serialize_color_data(nhist_data[i])
#print(nir_traits)
add_plantcv_metadata(session, url, nir_id, nir_traits)
# Add data to traits table
traits['tv_area'] = vis_traits['area']
return traits
def process_sv_images(vis_img, nir_img, debug=None):
"""Process side-view images.
Inputs:
vis_img = An RGB image.
nir_img = An NIR grayscale image.
debug = None, print, or plot. Print = save to file, Plot = print to screen.
:param vis_img: str
:param nir_img: str
:param debug: str
:return:
"""
# Read VIS image
img, path, filename = pcv.readimage(vis_img)
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 36, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
# device, s_fill = pcv.fill(s_mblur, s_cnt, 0, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
device, b_cnt = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
# Fill small objects
# device, b_fill = pcv.fill(b_thresh, b_cnt, 10, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_mblur, b_cnt, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked_a = pcv.rgb2gray_lab(masked, 'a', device, debug)
device, masked_b = pcv.rgb2gray_lab(masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, maskeda_thresh = pcv.binary_threshold(masked_a, 127, 255, 'dark', device, debug)
device, maskedb_thresh = pcv.binary_threshold(masked_b, 128, 255, 'light', device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, ab = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
device, ab_cnt = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
# Fill small noise
device, ab_fill1 = pcv.fill(ab, ab_cnt, 200, device, debug)
# Dilate to join small objects with larger ones
device, ab_cnt1 = pcv.dilate(ab_fill1, 3, 2, device, debug)
device, ab_cnt2 = pcv.dilate(ab_fill1, 3, 2, device, debug)
# Fill dilated image mask
device, ab_cnt3 = pcv.fill(ab_cnt2, ab_cnt1, 150, device, debug)
device, masked2 = pcv.apply_mask(masked, ab_cnt3, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked2_a = pcv.rgb2gray_lab(masked2, 'a', device, debug)
device, masked2_b = pcv.rgb2gray_lab(masked2, 'b', device, debug)
# Threshold the green-magenta and blue images
device, masked2a_thresh = pcv.binary_threshold(masked2_a, 127, 255, 'dark', device, debug)
device, masked2b_thresh = pcv.binary_threshold(masked2_b, 128, 255, 'light', device, debug)
device, masked2a_thresh_blur = pcv.median_blur(masked2a_thresh, 5, device, debug)
device, masked2b_thresh_blur = pcv.median_blur(masked2b_thresh, 13, device, debug)
device, ab_fill = pcv.logical_or(masked2a_thresh_blur, masked2b_thresh_blur, device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, ab_fill, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(masked2, 'rectangle', device, None, 'default', debug, True, 700,
0, -600, -300)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img, 'partial', roi1, roi_hierarchy,
id_objects, obj_hierarchy, device,
debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3, device, debug)
############## VIS Analysis ################
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(img, vis_img, obj, mask, device, debug)
# Shape properties relative to user boundary line (optional)
device, boundary_header, boundary_data, boundary_img1 = pcv.analyze_bound(img, vis_img, obj, mask, 384, device,
debug)
# Determine color properties: Histograms, Color Slices and
# Pseudocolored Images, output color analyzed images (optional)
device, color_header, color_data, color_img = pcv.analyze_color(img, vis_img, mask, 256, device, debug,
None, 'v', 'img', 300)
# Output shape and color data
print('\t'.join(map(str, shape_header)) + '\n')
print('\t'.join(map(str, shape_data)) + '\n')
for row in shape_img:
print('\t'.join(map(str, row)) + '\n')
print('\t'.join(map(str, color_header)) + '\n')
print('\t'.join(map(str, color_data)) + '\n')
print('\t'.join(map(str, boundary_header)) + '\n')
print('\t'.join(map(str, boundary_data)) + '\n')
print('\t'.join(map(str, boundary_img1)) + '\n')
for row in color_img:
print('\t'.join(map(str, row)) + '\n')
############################# Use VIS image mask for NIR image#########################
# Read NIR image
nir, path1, filename1 = pcv.readimage(nir_img)
nir2 = cv2.imread(nir_img, -1)
# Flip mask
device, f_mask = pcv.flip(mask, "vertical", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.1154905775, 0.1154905775, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir, nmask, device, 30, 4, "top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(nir2, filename1, nir_combinedmask, 256,
device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir2, filename1, nir_combined, nir_combinedmask,
device, debug)
print('\t'.join(map(str, nhist_header)) + '\n')
print('\t'.join(map(str, nhist_data)) + '\n')
for row in nir_imgs:
print('\t'.join(map(str, row)) + '\n')
print('\t'.join(map(str, nshape_header)) + '\n')
print('\t'.join(map(str, nshape_data)) + '\n')
print('\t'.join(map(str, nir_shape)) + '\n')
def process_tv_images(vis_img, nir_img, debug=False):
"""Process top-view images.
Inputs:
vis_img = An RGB image.
nir_img = An NIR grayscale image.
debug = None, print, or plot. Print = save to file, Plot = print to screen.
:param vis_img: str
:param nir_img: str
:param debug: str
:return:
"""
# Read image
img, path, filename = pcv.readimage(vis_img)
brass_mask = cv2.imread('mask_brass_tv_z1_L1.png')
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 75, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
device, s_fill = pcv.fill(s_mblur, s_cnt, 150, device, debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
device, b_cnt = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
# Fill small objects
device, b_fill = pcv.fill(b_thresh, b_cnt, 100, device, debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_fill, b_fill, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(img, bs, 'white', device, debug)
# Mask pesky brass piece
device, brass_mask1 = pcv.rgb2gray_hsv(brass_mask, 'v', device, debug)
device, brass_thresh = pcv.binary_threshold(brass_mask1, 0, 255, 'light', device, debug)
device, brass_inv = pcv.invert(brass_thresh, device, debug)
device, brass_masked = pcv.apply_mask(masked, brass_inv, 'white', device, debug)
# Further mask soil and car
device, masked_a = pcv.rgb2gray_lab(brass_masked, 'a', device, debug)
device, soil_car1 = pcv.binary_threshold(masked_a, 128, 255, 'dark', device, debug)
device, soil_car2 = pcv.binary_threshold(masked_a, 128, 255, 'light', device, debug)
device, soil_car = pcv.logical_or(soil_car1, soil_car2, device, debug)
device, soil_masked = pcv.apply_mask(brass_masked, soil_car, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, soil_a = pcv.rgb2gray_lab(soil_masked, 'a', device, debug)
device, soil_b = pcv.rgb2gray_lab(soil_masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, soila_thresh = pcv.binary_threshold(soil_a, 124, 255, 'dark', device, debug)
device, soilb_thresh = pcv.binary_threshold(soil_b, 148, 255, 'light', device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, soil_ab = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
device, soil_ab_cnt = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
# Fill small objects
device, soil_cnt = pcv.fill(soil_ab, soil_ab_cnt, 300, device, debug)
# Apply mask (for vis images, mask_color=white)
device, masked2 = pcv.apply_mask(soil_masked, soil_cnt, 'white', device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(masked2, soil_cnt, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(img, 'rectangle', device, None, 'default', debug, True, 600, 450, -600,
-350)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img, 'partial', roi1, roi_hierarchy,
id_objects, obj_hierarchy, device, debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(img, roi_objects, hierarchy3, device, debug)
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(img, vis_img, obj, mask, device, debug)
# Determine color properties
device, color_header, color_data, color_img = pcv.analyze_color(img, vis_img, mask, 256, device, debug, None,
'v', 'img', 300)
print('\t'.join(map(str, shape_header)) + '\n')
print('\t'.join(map(str, shape_data)) + '\n')
for row in shape_img:
print('\t'.join(map(str, row)) + '\n')
print('\t'.join(map(str, color_header)) + '\n')
print('\t'.join(map(str, color_data)) + '\n')
for row in color_img:
print('\t'.join(map(str, row)) + '\n')
############################# Use VIS image mask for NIR image#########################
# Read NIR image
nir, path1, filename1 = pcv.readimage(nir_img)
nir2 = cv2.imread(nir_img, -1)
# Flip mask
device, f_mask = pcv.flip(mask, "horizontal", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.116148, 0.116148, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir, nmask, device, 15, 5, "top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(nir, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(nir, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(nir2, filename1, nir_combinedmask, 256,
device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(nir2, filename1, nir_combined, nir_combinedmask,
device, debug)
print('\t'.join(map(str,nhist_header)) + '\n')
print('\t'.join(map(str,nhist_data)) + '\n')
for row in nir_imgs:
print('\t'.join(map(str,row)) + '\n')
print('\t'.join(map(str,nshape_header)) + '\n')
print('\t'.join(map(str,nshape_data)) + '\n')
print('\t'.join(map(str,nir_shape)) + '\n')
def process_tv_images_core(vis_id,
vis_img,
nir_id,
nir_rgb,
nir_cv2,
brass_mask,
traits,
debug=None):
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(vis_img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 75, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
device, s_fill = pcv.fill(s_mblur, s_cnt, 150, device, debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(vis_img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 138, 255, 'light', device,
debug)
device, b_cnt = pcv.binary_threshold(b, 138, 255, 'light', device, debug)
# Fill small objects
device, b_fill = pcv.fill(b_thresh, b_cnt, 100, device, debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_fill, b_fill, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(vis_img, bs, 'white', device, debug)
# Mask pesky brass piece
device, brass_mask1 = pcv.rgb2gray_hsv(brass_mask, 'v', device, debug)
device, brass_thresh = pcv.binary_threshold(brass_mask1, 0, 255, 'light',
device, debug)
device, brass_inv = pcv.invert(brass_thresh, device, debug)
device, brass_masked = pcv.apply_mask(masked, brass_inv, 'white', device,
debug)
# Further mask soil and car
device, masked_a = pcv.rgb2gray_lab(brass_masked, 'a', device, debug)
device, soil_car1 = pcv.binary_threshold(masked_a, 128, 255, 'dark',
device, debug)
device, soil_car2 = pcv.binary_threshold(masked_a, 128, 255, 'light',
device, debug)
device, soil_car = pcv.logical_or(soil_car1, soil_car2, device, debug)
device, soil_masked = pcv.apply_mask(brass_masked, soil_car, 'white',
device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, soil_a = pcv.rgb2gray_lab(soil_masked, 'a', device, debug)
device, soil_b = pcv.rgb2gray_lab(soil_masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, soila_thresh = pcv.binary_threshold(soil_a, 124, 255, 'dark',
device, debug)
device, soilb_thresh = pcv.binary_threshold(soil_b, 148, 255, 'light',
device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, soil_ab = pcv.logical_or(soila_thresh, soilb_thresh, device, debug)
device, soil_ab_cnt = pcv.logical_or(soila_thresh, soilb_thresh, device,
debug)
# Fill small objects
device, soil_cnt = pcv.fill(soil_ab, soil_ab_cnt, 300, device, debug)
# Apply mask (for vis images, mask_color=white)
device, masked2 = pcv.apply_mask(soil_masked, soil_cnt, 'white', device,
debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(
masked2, soil_cnt, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(vis_img, 'rectangle', device,
None, 'default', debug, True,
600, 450, -600, -350)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
vis_img, 'partial', roi1, roi_hierarchy, id_objects, obj_hierarchy,
device, debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(vis_img, roi_objects,
hierarchy3, device, debug)
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(
vis_img, vis_id, obj, mask, device, debug)
# Determine color properties
device, color_header, color_data, color_img = pcv.analyze_color(
vis_img, vis_id, mask, 256, device, debug, None, 'v', 'img', 300)
# Output shape and color data
vis_traits = {}
for i in range(1, len(shape_header)):
vis_traits[shape_header[i]] = shape_data[i]
for i in range(2, len(color_header)):
vis_traits[color_header[i]] = serialize_color_data(color_data[i])
############################# Use VIS image mask for NIR image#########################
# Flip mask
device, f_mask = pcv.flip(mask, "horizontal", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.116148, 0.116148, device, debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir_rgb, nmask, device, 15, 5,
"top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(
nir_rgb, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(
nir_rgb, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(
nir_cv2, nir_id, nir_combinedmask, 256, device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(
nir_cv2, nir_id, nir_combined, nir_combinedmask, device, debug)
nir_traits = {}
for i in range(1, len(nshape_header)):
nir_traits[nshape_header[i]] = nshape_data[i]
for i in range(2, len(nhist_header)):
nir_traits[nhist_header[i]] = serialize_color_data(nhist_data[i])
# Add data to traits table
traits['tv_area'] = vis_traits['area']
return [vis_traits, nir_traits]
def process_sv_images_core(vis_id,
vis_img,
nir_id,
nir_rgb,
nir_cv2,
traits,
debug=None):
# Pipeline step
device = 0
# Convert RGB to HSV and extract the Saturation channel
device, s = pcv.rgb2gray_hsv(vis_img, 's', device, debug)
# Threshold the Saturation image
device, s_thresh = pcv.binary_threshold(s, 36, 255, 'light', device, debug)
# Median Filter
device, s_mblur = pcv.median_blur(s_thresh, 5, device, debug)
device, s_cnt = pcv.median_blur(s_thresh, 5, device, debug)
# Fill small objects
# device, s_fill = pcv.fill(s_mblur, s_cnt, 0, device, args.debug)
# Convert RGB to LAB and extract the Blue channel
device, b = pcv.rgb2gray_lab(vis_img, 'b', device, debug)
# Threshold the blue image
device, b_thresh = pcv.binary_threshold(b, 137, 255, 'light', device,
debug)
device, b_cnt = pcv.binary_threshold(b, 137, 255, 'light', device, debug)
# Fill small objects
# device, b_fill = pcv.fill(b_thresh, b_cnt, 10, device, args.debug)
# Join the thresholded saturation and blue-yellow images
device, bs = pcv.logical_and(s_mblur, b_cnt, device, debug)
# Apply Mask (for vis images, mask_color=white)
device, masked = pcv.apply_mask(vis_img, bs, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked_a = pcv.rgb2gray_lab(masked, 'a', device, debug)
device, masked_b = pcv.rgb2gray_lab(masked, 'b', device, debug)
# Threshold the green-magenta and blue images
device, maskeda_thresh = pcv.binary_threshold(masked_a, 127, 255, 'dark',
device, debug)
device, maskedb_thresh = pcv.binary_threshold(masked_b, 128, 255, 'light',
device, debug)
# Join the thresholded saturation and blue-yellow images (OR)
device, ab = pcv.logical_or(maskeda_thresh, maskedb_thresh, device, debug)
device, ab_cnt = pcv.logical_or(maskeda_thresh, maskedb_thresh, device,
debug)
# Fill small noise
device, ab_fill1 = pcv.fill(ab, ab_cnt, 200, device, debug)
# Dilate to join small objects with larger ones
device, ab_cnt1 = pcv.dilate(ab_fill1, 3, 2, device, debug)
device, ab_cnt2 = pcv.dilate(ab_fill1, 3, 2, device, debug)
# Fill dilated image mask
device, ab_cnt3 = pcv.fill(ab_cnt2, ab_cnt1, 150, device, debug)
device, masked2 = pcv.apply_mask(masked, ab_cnt3, 'white', device, debug)
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
device, masked2_a = pcv.rgb2gray_lab(masked2, 'a', device, debug)
device, masked2_b = pcv.rgb2gray_lab(masked2, 'b', device, debug)
# Threshold the green-magenta and blue images
device, masked2a_thresh = pcv.binary_threshold(masked2_a, 127, 255, 'dark',
device, debug)
device, masked2b_thresh = pcv.binary_threshold(masked2_b, 128, 255,
'light', device, debug)
device, masked2a_thresh_blur = pcv.median_blur(masked2a_thresh, 5, device,
debug)
device, masked2b_thresh_blur = pcv.median_blur(masked2b_thresh, 13, device,
debug)
device, ab_fill = pcv.logical_or(masked2a_thresh_blur,
masked2b_thresh_blur, device, debug)
# Identify objects
device, id_objects, obj_hierarchy = pcv.find_objects(
masked2, ab_fill, device, debug)
# Define ROI
device, roi1, roi_hierarchy = pcv.define_roi(masked2, 'rectangle', device,
None, 'default', debug, True,
700, 0, -600, -300)
# Decide which objects to keep
device, roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
vis_img, 'partial', roi1, roi_hierarchy, id_objects, obj_hierarchy,
device, debug)
# Object combine kept objects
device, obj, mask = pcv.object_composition(vis_img, roi_objects,
hierarchy3, device, debug)
############## VIS Analysis ################
# Find shape properties, output shape image (optional)
device, shape_header, shape_data, shape_img = pcv.analyze_object(
vis_img, vis_id, obj, mask, device, debug)
# Shape properties relative to user boundary line (optional)
device, boundary_header, boundary_data, boundary_img1 = pcv.analyze_bound(
vis_img, vis_id, obj, mask, 384, device, debug)
# Determine color properties: Histograms, Color Slices and
# Pseudocolored Images, output color analyzed images (optional)
device, color_header, color_data, color_img = pcv.analyze_color(
vis_img, vis_id, mask, 256, device, debug, None, 'v', 'img', 300)
# Output shape and color data
vis_traits = {}
for i in range(1, len(shape_header)):
vis_traits[shape_header[i]] = shape_data[i]
for i in range(1, len(boundary_header)):
vis_traits[boundary_header[i]] = boundary_data[i]
for i in range(2, len(color_header)):
vis_traits[color_header[i]] = serialize_color_data(color_data[i])
############################# Use VIS image mask for NIR image#########################
# Flip mask
device, f_mask = pcv.flip(mask, "vertical", device, debug)
# Reize mask
device, nmask = pcv.resize(f_mask, 0.1154905775, 0.1154905775, device,
debug)
# position, and crop mask
device, newmask = pcv.crop_position_mask(nir_rgb, nmask, device, 30, 4,
"top", "right", debug)
# Identify objects
device, nir_objects, nir_hierarchy = pcv.find_objects(
nir_rgb, newmask, device, debug)
# Object combine kept objects
device, nir_combined, nir_combinedmask = pcv.object_composition(
nir_rgb, nir_objects, nir_hierarchy, device, debug)
####################################### Analysis #############################################
device, nhist_header, nhist_data, nir_imgs = pcv.analyze_NIR_intensity(
nir_cv2, nir_id, nir_combinedmask, 256, device, False, debug)
device, nshape_header, nshape_data, nir_shape = pcv.analyze_object(
nir_cv2, nir_id, nir_combined, nir_combinedmask, device, debug)
nir_traits = {}
for i in range(1, len(nshape_header)):
nir_traits[nshape_header[i]] = nshape_data[i]
for i in range(2, len(nhist_header)):
nir_traits[nhist_header[i]] = serialize_color_data(nhist_data[i])
# Add data to traits table
traits['sv_area'].append(vis_traits['area'])
traits['hull_area'].append(vis_traits['hull-area'])
traits['solidity'].append(vis_traits['solidity'])
traits['height'].append(vis_traits['height_above_bound'])
traits['perimeter'].append(vis_traits['perimeter'])
return [vis_traits, nir_traits]
def test_plantcv_flip():
img = cv2.imread(os.path.join(TEST_DATA, TEST_INPUT_COLOR))
device, flipped_img = pcv.flip(img=img, direction="horizontal", device=0, debug=None)
assert all([i == j] for i, j in zip(np.shape(flipped_img), TEST_COLOR_DIM))