def calculation(image, img_path):
PIL_image = Image.fromarray(np.uint8(image)).convert('RGB')
invert_im = ImageOps.invert(PIL_image) # invert image (so that white is 0)
imageBox = invert_im.getbbox()
cropped = PIL_image.crop(imageBox)
image = np.asanyarray(cropped)
s = pcv.rgb2gray_hsv(rgb_img=image, channel='s')
s_thresh = pcv.threshold.binary(gray_img=s,
threshold=150,
max_value=255,
object_type='light')
area = get_area(s_thresh, s_thresh.shape[0])
output_path_area = os.path.dirname(img_path) + "/" + os.path.basename(
img_path) + "_area.jpg"
imsave(output_path_area, s_thresh)
img2 = np.copy(image)
img2[s_thresh == 0] = 0
health = get_area(img2[:, :, 1], s_thresh.shape[0])
output_path_health = os.path.dirname(img_path) + "/" + os.path.basename(
img_path) + "_health.jpg"
imsave(output_path_health, img2[:, :, 1])
results = {"healthy_size": health, "size": area}
return (results)
def plant_cv(img):
counter = 0
debug = None
counter, s = pcv.rgb2gray_hsv(img, 's', counter, debug)
counter, s_thresh = pcv.binary_threshold(s, 145, 255, 'light', counter,
debug)
counter, s_mblur = pcv.median_blur(s_thresh, 5, counter, debug)
# Convert RGB to LAB and extract the Blue channel
counter, b = pcv.rgb2gray_lab(img, 'b', counter, debug)
# Threshold the blue image
counter, b_thresh = pcv.binary_threshold(b, 145, 255, 'light', counter,
debug)
counter, b_cnt = pcv.binary_threshold(b, 145, 255, 'light', counter, debug)
# Join the thresholded saturation and blue-yellow images
counter, bs = pcv.logical_or(s_mblur, b_cnt, counter, debug)
counter, masked = pcv.apply_mask(img, bs, 'white', counter, debug)
#----------------------------------------
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
counter, masked_a = pcv.rgb2gray_lab(masked, 'a', counter, debug)
counter, masked_b = pcv.rgb2gray_lab(masked, 'b', counter, debug)
# Threshold the green-magenta and blue images
counter, maskeda_thresh = pcv.binary_threshold(masked_a, 115, 255, 'dark',
counter, debug)
counter, maskeda_thresh1 = pcv.binary_threshold(masked_a, 135, 255,
'light', counter, debug)
counter, maskedb_thresh = pcv.binary_threshold(masked_b, 128, 255, 'light',
counter, debug)
# Join the thresholded saturation and blue-yellow images (OR)
counter, ab1 = pcv.logical_or(maskeda_thresh, maskedb_thresh, counter,
debug)
counter, ab = pcv.logical_or(maskeda_thresh1, ab1, counter, debug)
counter, ab_cnt = pcv.logical_or(maskeda_thresh1, ab1, counter, debug)
# Fill small objects
counter, ab_fill = pcv.fill(ab, ab_cnt, 200, counter, debug)
# Apply mask (for vis images, mask_color=white)
counter, masked2 = pcv.apply_mask(masked, ab_fill, 'white', counter, debug)
zeros = np.zeros(masked2.shape[:2], dtype="uint8")
merged = cv2.merge([zeros, ab_fill, zeros])
return merged, masked2
def generate_plant_mask_new(input_image):
'''
Generate a mask which segments the plant out in the input image
Ref: https://plantcv.readthedocs.io/en/latest/vis_tutorial/
Args:
input_image: the input image
Returns:
mask: boolean numpy array as the same size of the input image which segments the plant
'''
# Get the saturation channel
# hsv_image = rgb2hsv(input_image)
# s = hsv_image[:,:,1]
s = pcv.rgb2gray_hsv(rgb_img=input_image, channel='s')
# threshold the saturation image
s_thresh = s > 130
# perform blur on the thresholding
# s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
s_cnt = pcv.median_blur(gray_img=s_thresh, ksize=15)
# extract the LAb channels and theshold them
b = pcv.rgb2gray_lab(rgb_img=input_image, channel='b')
a = pcv.rgb2gray_lab(rgb_img=input_image, channel='a')
a_thresh = a <= 120
b_thresh = b >= 105
lab_mask = np.logical_and(a_thresh, b_thresh)
lab_cnt = pcv.median_blur(gray_img=lab_mask, ksize=15)
# join the two thresholdes mask
bs = np.logical_and(s_cnt, lab_cnt)
# filling small holes
res = np.ones(bs.shape, dtype=np.uint8) * 255
res[bs] = 0
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
res = cv2.morphologyEx(res, cv2.MORPH_OPEN, kernel)
res = res == 0
return res
def read_true_positive(true_positive_file):
class args:
#image = "C:\\Users\\RensD\\OneDrive\\studie\\Master\\The_big_project\\top_perspective\\0214_2018-03-07 08.55 - 26_true_positive.png"
image = true_positive_file
outdir = "C:\\Users\\RensD\\OneDrive\\studie\\Master\\The_big_project\\top_perspective\\output"
debug = "None"
result = "results.txt"
# Get options
pcv.params.debug = args.debug #set debug mode
pcv.params.debug_outdir = args.outdir #set output directory
# Read image (readimage mode defaults to native but if image is RGBA then specify mode='rgb')
# Inputs:
# filename - Image file to be read in
# mode - Return mode of image; either 'native' (default), 'rgb', 'gray', or 'csv'
img, path, filename = pcv.readimage(filename=args.image, mode='rgb')
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
mask, masked_image = pcv.threshold.custom_range(rgb_img=s,
lower_thresh=[10],
upper_thresh=[255],
channel='gray')
masked = pcv.apply_mask(rgb_img=img, mask=mask, mask_color='white')
#new_im = Image.fromarray(mask)
#name = "positive_test.png"
#Recognizing objects
id_objects, obj_hierarchy = pcv.find_objects(masked, mask)
roi1, roi_hierarchy = pcv.roi.rectangle(img=masked,
x=0,
y=0,
h=960,
w=1280) # Currently hardcoded
with HiddenPrints():
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img=img,
roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type=roi_type)
obj, mask = pcv.object_composition(img=img,
contours=roi_objects,
hierarchy=hierarchy3)
#new_im.save(name)
return (mask)
def plot_hotspots(directory, filename):
# Read image
in_full_path = os.path.join(directory, filename)
outfile = 'Hotspot' + filename
out_full_path = os.path.join(directory, outfile)
img, path, filename = pcv.readimage(in_full_path, mode="rgb")
# Convert RGB to HSV and extract the saturation channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Threshold the saturation image
s_thresh = pcv.threshold.binary(gray_img=s,
threshold=85,
max_value=255,
object_type='light')
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
edge = cv2.Canny(s_mblur, 60, 180)
fig, ax = plt.subplots(1, figsize=(12, 8))
plt.imshow(edge, cmap='Greys')
contours, hierarchy = cv2.findContours(edge.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[-2:]
centroids = []
contours = sorted(contours, key=cv2.contourArea, reverse=True)
for i, cnt in enumerate(contours):
if (cv2.contourArea(cnt) > 10):
moment = cv2.moments(contours[i])
Cx = int(moment["m10"] / moment["m00"])
Cy = int(moment["m01"] / moment["m00"])
center = (Cx, Cy)
centroids.append((contours, center, moment["m00"], 0))
cv2.circle(img, (Cx, Cy), 5, (255, 255, 255), -1)
coordinate = '(' + str(Cx) + ',' + str(Cy) + ')'
cv2.putText(img, coordinate, (Cx, Cy), cv2.FONT_HERSHEY_SIMPLEX,
0.5, RED, 1, cv2.LINE_AA)
print(cv2.contourArea(cnt), Cx, Cy)
cv2.imwrite(out_full_path, img)
#cv2.imshow('canvasOutput', img);
#cv2.waitKey(0)
return
def main():
# Get options
args = options()
pcv.params.debug = args.debug # set debug mode
pcv.params.debug_outdir = args.outdir # set output directory
# Read image
img, path, filename = pcv.readimage(filename=args.image)
# Convert RGB to HSV and extract the saturation channel
h = pcv.rgb2gray_hsv(rgb_img=img, channel='h')
# Threshold the saturation image
h_thresh = pcv.threshold.binary(gray_img=h,
threshold=85,
max_value=255,
object_type='dark')
# Median Blur
h_mblur = pcv.median_blur(gray_img=h_thresh, ksize=20)
# In[ ]:
# This command outputs all resulting images to the notebook.
pcv.params.debug = 'plot'
# In[6]:
# Importing the image. Including the path was necessary. Mode="native" by default.
img, path, img_filename = pcv.readimage(
filename="/users/jordanmanchengo/data/duckweed1.png")
# In[11]:
# Hue channel.
h = pcv.rgb2gray_hsv(rgb_img=img, channel='h')
# In[12]:
# Saturation channel.
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# In[13]:
# Value channel.
v = pcv.rgb2gray_hsv(rgb_img=img, channel='v')
# In[14]:
# Setting a saturation threshold on "light" objects to create sharp contrast.
s_thresh = pcv.threshold.binary(gray_img=s,
def plantCVProcess(img, x, y, w, h):
# Convert RGB to HSV and extract the saturation channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Threshold the saturation image
s_thresh = pcv.threshold.binary(gray_img=s, threshold=85, max_value=255, object_type='light')
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
s_cnt = pcv.median_blur(gray_img=s_thresh, ksize=5)
# Convert RGB to LAB and extract the Blue channel
b = pcv.rgb2gray_lab(rgb_img=img, channel='b')
# Threshold the blue image
b_thresh = pcv.threshold.binary(gray_img=b, threshold=160, max_value=255, object_type='light')
b_cnt = pcv.threshold.binary(gray_img=b, threshold=160, max_value=255, object_type='light')
# Fill small objects
# b_fill = pcv.fill(b_thresh, 10)
# Join the thresholded saturation and blue-yellow images
bs = pcv.logical_or(bin_img1=s_mblur, bin_img2=b_cnt)
# Apply Mask (for VIS images, mask_color=white)
masked = pcv.apply_mask(img=img, mask=bs, mask_color='white')
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
# Threshold the green-magenta and blue images
maskeda_thresh = pcv.threshold.binary(gray_img=masked_a, threshold=115, max_value=255, object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(gray_img=masked_a, threshold=135, max_value=255, object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b, threshold=128, max_value=255, object_type='light')
# Join the thresholded saturation and blue-yellow images (OR)
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
# Fill small objects
ab_fill = pcv.fill(bin_img=ab, size=200)
# Apply mask (for VIS images, mask_color=white)
masked2 = pcv.apply_mask(img=masked, mask=ab_fill, mask_color='white')
# Identify objects
id_objects, obj_hierarchy = pcv.find_objects(img=masked2, mask=ab_fill)
# Define ROI
roi1, roi_hierarchy = pcv.roi.rectangle(img=masked2, x=x, y=y, h=h, w=w)
# Decide which objects to keep
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img=img, roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type='partial')
# Object combine kept objects
obj, mask = pcv.object_composition(img=img, contours=roi_objects, hierarchy=hierarchy3)
############### Analysis ################
# Find shape properties, output shape image (optional)
shape_imgs = pcv.analyze_object(img=img, obj=obj, mask=mask)
# Shape properties relative to user boundary line (optional)
boundary_img1 = pcv.analyze_bound_horizontal(img=img, obj=obj, mask=mask, line_position=1680)
# Determine color properties: Histograms, Color Slices, output color analyzed histogram (optional)
color_histogram = pcv.analyze_color(rgb_img=img, mask=mask, hist_plot_type='all')
# Pseudocolor the grayscale image
pseudocolored_img = pcv.visualize.pseudocolor(gray_img=s, mask=mask, cmap='jet')
return print_results()
client.connect(server, username = sshuser, pkey = mykey)
client.get_transport().window_size = 3 * 1024 * 1024
pcv.params.debug = 'none'
sftp = client.open_sftp()
with sftp.open('/plantdb/ftp-2019/{dbname}/{path}'.format(dbname=dbname,path=path)) as f:
file_size = f.stat().st_size
f.prefetch(file_size)
img = cv2.imdecode(np.frombuffer(f.read(file_size), np.uint8), 1)
# Convert RGB to HSV and extract the value channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='v')
# Threshold the saturation image removing highs and lows and join
s_thresh_1 = pcv.threshold.binary(gray_img=s, threshold=10, max_value=255, object_type='light')
s_thresh_2 = pcv.threshold.binary(gray_img=s, threshold=245, max_value=255, object_type='dark')
s_thresh = pcv.logical_and(bin_img1=s_thresh_1, bin_img2=s_thresh_2)
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
# Convert RGB to LAB and extract the Blue channel
b = pcv.rgb2gray_lab(rgb_img=img, channel='b')
# Threshold the blue image
b_cnt = pcv.threshold.binary(gray_img=b, threshold=128, max_value=255, object_type='light')
# ir_ir = frames.get_infrared()
# cv2.imshow('aligned', ir_ir)
# aligned_depth_color_frame = rs.colorizer().colorize(aligned_depth_frame)
# aligned_depth_color_image = np.asanyarray(aligned_depth_color_frame.get_data())
# cv2.imshow('aligned', aligned_depth_color_image)
# Validate that both frames are valid
if not aligned_depth_frame or not color_frame:
continue
depth_image = np.asanyarray(aligned_depth_frame.get_data())
color_image = np.asanyarray(color_frame.get_data())
s = pcv.rgb2gray_hsv(color_image, 's') # plantcv
s_thresh = pcv.threshold.binary(s, 85, 255, 'light') # plantcv
s_mblur = pcv.median_blur(s_thresh, 5)
s_cnt = pcv.median_blur(s_thresh, 5)
# cv2.imshow('color - depth3', s_mblur)
# Convert RGB to LAB and extract the Blue channel
b = pcv.rgb2gray_lab(color_image, 'b')
# Threshold the blue image
b_thresh = pcv.threshold.binary(b, 160, 255, 'light')
b_cnt = pcv.threshold.binary(b, 160, 255, 'light')
# Fill small objects
# b_fill = pcv.fill(b_thresh, 10)
mask = pcv.naive_bayes_classifier(color_image, "naive_bayes_pdfs.txt")
#histogram_low = np.sum(mask["plant"][int(360/2):, :], axis=0)
def main():
# Get options
args = options()
# Set variables
pcv.params.debug = args.debug # Replace the hard-coded debug with the debug flag
pcv.params.debug_outdir = args.outdir # set output directory
### Main pipeline ###
# Read image (readimage mode defaults to native but if image is RGBA then specify mode='rgb')
img, path, filename = pcv.readimage(args.image, mode='rgb')
# Read reference image for colour correction (currently unused)
#ref_img, ref_path, ref_filename = pcv.readimage(
# "/home/leonard/Dropbox/2020-01_LAC_phenotyping/images/top/renamed/20200128_2.jpg",
# mode="rgb")
# Find colour cards
#df, start, space = pcv.transform.find_color_card(rgb_img=ref_img)
#ref_mask = pcv.transform.create_color_card_mask(rgb_img=ref_img, radius=10, start_coord=start, spacing=space, ncols=4, nrows=6)
df, start, space = pcv.transform.find_color_card(rgb_img=img)
img_mask = pcv.transform.create_color_card_mask(rgb_img=img,
radius=10,
start_coord=start,
spacing=space,
ncols=4,
nrows=6)
output_directory = "."
# Correct colour (currently unused)
#target_matrix, source_matrix, transformation_matrix, corrected_img = pcv.transform.correct_color(ref_img, ref_mask, img, img_mask, output_directory)
# Check that the colour correction worked (source~target should be strictly linear)
#pcv.transform.quick_color_check(source_matrix = source_matrix, target_matrix = target_matrix, num_chips = 24)
# Write the spacing of the colour card to file as size marker
with open(os.path.join(path, 'output/size_marker_trays.csv'), 'a') as f:
writer = csv.writer(f)
writer.writerow([filename, space[0]])
### Crop tray ###
# Define a bounding rectangle around the colour card
x_cc, y_cc, w_cc, h_cc = cv2.boundingRect(img_mask)
x_cc = int(round(x_cc - 0.3 * w_cc))
y_cc = int(round(y_cc - 0.3 * h_cc))
h_cc = int(round(h_cc * 1.6))
w_cc = int(round(w_cc * 1.6))
# Crop out colour card
start_point = (x_cc, y_cc)
end_point = (x_cc + w_cc, y_cc + h_cc)
colour = (0, 0, 0)
thickness = -1
card_crop_img = cv2.rectangle(img, start_point, end_point, colour,
thickness)
# Convert RGB to HSV and extract the value channel
v = pcv.rgb2gray_hsv(card_crop_img, "v")
# Threshold the value image
v_thresh = pcv.threshold.binary(
v, 100, 255, "light"
) # start threshold at 150 with bright corner-markers, 100 without
# Fill out bright imperfections (siliques and other dirt on the background)
v_thresh = pcv.fill(
v_thresh, 100) # fill at 500 with bright corner-markers, 100 without
# Create bounding rectangle around the tray
x, y, w, h = cv2.boundingRect(v_thresh)
# Crop image to tray
#crop_img = card_crop_img[y:y+h, x:x+int(w - (w * 0.03))] # crop extra 3% from right because of tray labels
crop_img = card_crop_img[y:y + h, x:x + w] # crop symmetrically
# Save cropped image for quality control
pcv.print_image(crop_img,
filename=path + "/output/" + "cropped" + filename + ".png")
### Threshold plants ###
# Threshold the green-magenta, blue, and hue channels
a_thresh, _ = pcv.threshold.custom_range(img=crop_img,
lower_thresh=[0, 0, 0],
upper_thresh=[255, 108, 255],
channel='LAB')
b_thresh, _ = pcv.threshold.custom_range(img=crop_img,
lower_thresh=[0, 0, 135],
upper_thresh=[255, 255, 255],
channel='LAB')
h_thresh, _ = pcv.threshold.custom_range(img=crop_img,
lower_thresh=[35, 0, 0],
upper_thresh=[70, 255, 255],
channel='HSV')
# Join the thresholds (AND)
ab = pcv.logical_and(b_thresh, a_thresh)
abh = pcv.logical_and(ab, h_thresh)
# Fill small objects depending on expected plant size based on DPG (make sure to take the correct file suffix jpg/JPG/jpeg...)
match = re.search("(\d+).(\d)\.jpg$", filename)
if int(match.group(1)) < 10:
abh_clean = pcv.fill(abh, 50)
print("50")
elif int(match.group(1)) < 15:
abh_clean = pcv.fill(abh, 200)
print("200")
else:
abh_clean = pcv.fill(abh, 500)
print("500")
# Dilate to close broken borders
abh_dilated = pcv.dilate(abh_clean, 3, 1)
# Close holes
# abh_fill = pcv.fill_holes(abh_dilated) # silly -- removed
abh_fill = abh_dilated
# Apply mask (for VIS images, mask_color=white)
masked = pcv.apply_mask(crop_img, abh_fill, "white")
# Save masked image for quality control
pcv.print_image(masked,
filename=path + "/output/" + "masked" + filename + ".png")
### Filter and group contours ###
# Identify objects
id_objects, obj_hierarchy = pcv.find_objects(crop_img, abh_fill)
# Create bounding box with margins to avoid border artifacts
roi_y = 0 + crop_img.shape[0] * 0.05
roi_x = 0 + crop_img.shape[0] * 0.05
roi_h = crop_img.shape[0] - (crop_img.shape[0] * 0.1)
roi_w = crop_img.shape[1] - (crop_img.shape[0] * 0.1)
roi_contour, roi_hierarchy = pcv.roi.rectangle(crop_img, roi_y, roi_x,
roi_h, roi_w)
# Keep all objects in the bounding box
roi_objects, roi_obj_hierarchy, kept_mask, obj_area = pcv.roi_objects(
img=crop_img,
roi_type='partial',
roi_contour=roi_contour,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy)
# Cluster the objects by plant
clusters, contours, hierarchies = pcv.cluster_contours(
crop_img, roi_objects, roi_obj_hierarchy, 3, 5)
# Split image into single plants
out = args.outdir
#output_path, imgs, masks = pcv.cluster_contour_splitimg(crop_img,
# clusters,
# contours,
# hierarchies,
# out,
# file = filename)
### Analysis ###
# Approximate the position of the top left plant as grid start
coord_y = int(
round(((crop_img.shape[0] / 3) * 0.5) + (crop_img.shape[0] * 0.025)))
coord_x = int(
round(((crop_img.shape[1] / 5) * 0.5) + (crop_img.shape[1] * 0.025)))
# Set the ROI spacing relative to image dimensions
spc_y = int((round(crop_img.shape[0] - (crop_img.shape[0] * 0.05)) / 3))
spc_x = int((round(crop_img.shape[1] - (crop_img.shape[1] * 0.05)) / 5))
# Set the ROI radius relative to image width
if int(match.group(1)) < 16:
r = int(round(crop_img.shape[1] / 12.5))
else:
r = int(round(crop_img.shape[1] / 20))
# Make a grid of ROIs at the expected positions of plants
# This allows for gaps due to dead/not germinated plants, without messing up the plant numbering
imgs, masks = pcv.roi.multi(img=crop_img,
nrows=3,
ncols=5,
coord=(coord_x, coord_y),
radius=r,
spacing=(spc_x, spc_y))
# Loop through the ROIs in the grid
for i in range(0, len(imgs)):
# Find objects within the ROI
filtered_contours, filtered_hierarchy, filtered_mask, filtered_area = pcv.roi_objects(
img=crop_img,
roi_type="partial",
roi_contour=imgs[i],
roi_hierarchy=masks[i],
object_contour=id_objects,
obj_hierarchy=obj_hierarchy)
# Continue only if not empty
if len(filtered_contours) > 0:
# Combine objects within each ROI
plant_contour, plant_mask = pcv.object_composition(
img=crop_img,
contours=filtered_contours,
hierarchy=filtered_hierarchy)
# Analyse the shape of each plant
analysis_images = pcv.analyze_object(img=crop_img,
obj=plant_contour,
mask=plant_mask)
pcv.print_image(analysis_images,
filename=path + "/output/" + filename + "_" +
str(i) + "_analysed.png")
# Determine color properties
color_images = pcv.analyze_color(crop_img, plant_mask, "hsv")
# Watershed plant area to count leaves (computationally intensive, use when needed)
#watershed_images = pcv.watershed_segmentation(crop_img, plant_mask, 15)
# Print out a .json file with the analysis data for the plant
pcv.outputs.save_results(filename=path + "/" + filename + "_" +
str(i) + '.json')
# Clear the measurements stored globally into the Ouptuts class
pcv.outputs.clear()
def main():
# Initialize options
args = options()
# Set PlantCV debug mode to input debug method
pcv.params.debug = args.debug
# Use PlantCV to read in the input image. The function outputs an image as a NumPy array, the path to the file,
# and the image filename
img, path, filename = pcv.readimage(filename=args.image)
# ## Segmentation
# ### Saturation channel
# Convert the RGB image to HSV colorspace and extract the saturation channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Use a binary threshold to set an inflection value where all pixels in the grayscale saturation image below the
# threshold get set to zero (pure black) and all pixels at or above the threshold get set to 255 (pure white)
s_thresh = pcv.threshold.binary(gray_img=s, threshold=80, max_value=255, object_type='light')
# ### Blue-yellow channel
# Convert the RGB image to LAB colorspace and extract the blue-yellow channel
b = pcv.rgb2gray_lab(rgb_img=img, channel='b')
# Use a binary threshold to set an inflection value where all pixels in the grayscale blue-yellow image below the
# threshold get set to zero (pure black) and all pixels at or above the threshold get set to 255 (pure white)
b_thresh = pcv.threshold.binary(gray_img=b, threshold=134, max_value=255, object_type='light')
# ### Green-magenta channel
# Convert the RGB image to LAB colorspace and extract the green-magenta channel
a = pcv.rgb2gray_lab(rgb_img=img, channel='a')
# In the green-magenta image the plant pixels are darker than the background. Setting object_type="dark" will
# invert the image first and then use a binary threshold to set an inflection value where all pixels in the
# grayscale green-magenta image below the threshold get set to zero (pure black) and all pixels at or above the
# threshold get set to 255 (pure white)
a_thresh = pcv.threshold.binary(gray_img=a, threshold=122, max_value=255, object_type='dark')
# Combine the binary images for the saturation and blue-yellow channels. The "or" operator returns a binary image
# that is white when a pixel was white in either or both input images
bs = pcv.logical_or(bin_img1=s_thresh, bin_img2=b_thresh)
# Combine the binary images for the combined saturation and blue-yellow channels and the green-magenta channel.
# The "or" operator returns a binary image that is white when a pixel was white in either or both input images
bsa = pcv.logical_or(bin_img1=bs, bin_img2=a_thresh)
# The combined binary image labels plant pixels well but the background still has pixels labeled as foreground.
# Small white noise (salt) in the background can be removed by filtering white objects in the image by size and
# setting a size threshold where smaller objects can be removed
bsa_fill1 = pcv.fill(bin_img=bsa, size=15) # Fill small noise
# Before more stringent size filtering is done we want to connect plant parts that may still be disconnected from
# the main plant. Use a dilation to expand the boundary of white regions. Ksize is the size of a box scanned
# across the image and i is the number of times a scan is done
bsa_fill2 = pcv.dilate(gray_img=bsa_fill1, ksize=3, i=3)
# Remove small objects by size again but use a higher threshold
bsa_fill3 = pcv.fill(bin_img=bsa_fill2, size=250)
# Use the binary image to identify objects or connected components.
id_objects, obj_hierarchy = pcv.find_objects(img=img, mask=bsa_fill3)
# Because the background still contains pixels labeled as foreground, the object list contains background.
# Because these images were collected in an automated system the plant is always centered in the image at the
# same position each time. Define a region of interest (ROI) to set the area where we expect to find plant
# pixels. PlantCV can make simple ROI shapes like rectangles, circles, etc. but here we use a custom ROI to fit a
# polygon around the plant area
roi_custom, roi_hier_custom = pcv.roi.custom(img=img, vertices=[[1085, 1560], [1395, 1560], [1395, 1685],
[1890, 1744], [1890, 25], [600, 25], [615, 1744],
[1085, 1685]])
# Use the ROI to filter out objects found outside the ROI. When `roi_type = "cutto"` objects outside the ROI are
# cropped out. The default `roi_type` is "partial" which allows objects to overlap the ROI and be retained
roi_objects, hierarchy, kept_mask, obj_area = pcv.roi_objects(img=img, roi_contour=roi_custom,
roi_hierarchy=roi_hier_custom,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy, roi_type='cutto')
# Filter remaining objects by size again to remove any remaining background objects
filled_mask1 = pcv.fill(bin_img=kept_mask, size=350)
# Use a closing operation to first dilate (expand) and then erode (shrink) the plant to fill in any additional
# gaps in leaves or stems
filled_mask2 = pcv.closing(gray_img=filled_mask1)
# Remove holes or dark spot noise (pepper) in the plant binary image
filled_mask3 = pcv.fill_holes(filled_mask2)
# With the clean binary image identify the contour of the plant
id_objects, obj_hierarchy = pcv.find_objects(img=img, mask=filled_mask3)
# Because a plant or object of interest may be composed of multiple contours, it is required to combine all
# remaining contours into a single contour before measurements can be done
obj, mask = pcv.object_composition(img=img, contours=id_objects, hierarchy=obj_hierarchy)
# ## Measurements PlantCV has several built-in measurement or analysis methods. Here, basic measurements of size
# and shape are done. Additional typical modules would include plant height (`pcv.analyze_bound_horizontal`) and
# color (`pcv.analyze_color`)
shape_img = pcv.analyze_object(img=img, obj=obj, mask=mask)
# Save the shape image if requested
if args.writeimg:
outfile = os.path.join(args.outdir, filename[:-4] + "_shapes.png")
pcv.print_image(img=shape_img, filename=outfile)
# ## Morphology workflow
# Update a few PlantCV parameters for plotting purposes
pcv.params.text_size = 1.5
pcv.params.text_thickness = 5
pcv.params.line_thickness = 15
# Convert the plant mask into a "skeletonized" image where each path along the stem and leaves are a single pixel
# wide
skel = pcv.morphology.skeletonize(mask=mask)
# Sometimes wide parts of leaves or stems are skeletonized in the direction perpendicular to the main path. These
# "barbs" or "spurs" can be removed by pruning the skeleton to remove small paths. Pruning will also separate the
# individual path segments (leaves and stem parts)
pruned, segmented_img, segment_objects = pcv.morphology.prune(skel_img=skel, size=30, mask=mask)
pruned, segmented_img, segment_objects = pcv.morphology.prune(skel_img=pruned, size=3, mask=mask)
# Leaf and stem segments above are separated but only into individual paths. We can sort the segments into stem
# and leaf paths by identifying primary segments (stems; those that end in a branch point) and secondary segments
# (leaves; those that begin at a branch point and end at a tip point)
leaf_objects, other_objects = pcv.morphology.segment_sort(skel_img=pruned, objects=segment_objects, mask=mask)
# Label the segment unique IDs
segmented_img, labeled_id_img = pcv.morphology.segment_id(skel_img=pruned, objects=leaf_objects, mask=mask)
# Measure leaf insertion angles. Measures the angle between a line fit through the stem paths and a line fit
# through the first `size` points of each leaf path
labeled_angle_img = pcv.morphology.segment_insertion_angle(skel_img=pruned, segmented_img=segmented_img,
leaf_objects=leaf_objects, stem_objects=other_objects,
size=22)
# Save leaf angle image if requested
if args.writeimg:
outfile = os.path.join(args.outdir, filename[:-4] + "_leaf_insertion_angles.png")
pcv.print_image(img=labeled_angle_img, filename=outfile)
# ## Other potential morphological measurements There are many other functions that extract data from within the
# morphology sub-package of PlantCV. For our purposes, we are most interested in the relative angle between each
# leaf and the stem which we measure with `plantcv.morphology.segment_insertion_angle`. However, the following
# cells show some of the other traits that we are able to measure from images that can be succesfully sorted into
# primary and secondary segments.
# Segment the plant binary mask using the leaf and stem segments. Allows for the measurement of individual leaf
# areas
# filled_img = pcv.morphology.fill_segments(mask=mask, objects=leaf_objects)
# Measure the path length of each leaf (geodesic distance)
# labeled_img2 = pcv.morphology.segment_path_length(segmented_img=segmented_img, objects=leaf_objects)
# Measure the straight-line, branch point to tip distance (Euclidean) for each leaf
# labeled_img3 = pcv.morphology.segment_euclidean_length(segmented_img=segmented_img, objects=leaf_objects)
# Measure the curvature of each leaf (Values closer to 1 indicate that a segment is a straight line while larger
# values indicate the segment has more curvature)
# labeled_img4 = pcv.morphology.segment_curvature(segmented_img=segmented_img, objects=leaf_objects)
# Measure absolute leaf angles (angle of linear regression line fit to each leaf object) Note: negative values
# signify leaves to the left of the stem, positive values signify leaves to the right of the stem
# labeled_img5 = pcv.morphology.segment_angle(segmented_img=segmented_img, objects=leaf_objects)
# Measure leaf curvature in degrees
# labeled_img6 = pcv.morphology.segment_tangent_angle(segmented_img=segmented_img, objects=leaf_objects, size=35)
# Measure stem characteristics like stem angle and length
# stem_img = pcv.morphology.analyze_stem(rgb_img=img, stem_objects=other_objects)
# Remove unneeded observations (hack)
_ = pcv.outputs.observations.pop("tips")
_ = pcv.outputs.observations.pop("branch_pts")
angles = pcv.outputs.observations["segment_insertion_angle"]["value"]
remove_indices = []
for i, value in enumerate(angles):
if value == "NA":
remove_indices.append(i)
remove_indices.sort(reverse=True)
for i in remove_indices:
_ = pcv.outputs.observations["segment_insertion_angle"]["value"].pop(i)
# ## Save the results out to file for downsteam analysis
pcv.print_results(filename=args.result)
def main():
# Get options
args = options()
pcv.params.debug = args.debug # set debug mode
pcv.params.debug_outdir = args.outdir # set output directory
# Read image
img, path, filename = pcv.readimage(filename=args.image)
# Convert RGB to HSV and extract the saturation channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Threshold the saturation image
s_thresh = pcv.threshold.binary(gray_img=s,
threshold=85,
max_value=255,
object_type='light')
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
s_cnt = pcv.median_blur(gray_img=s_thresh, ksize=5)
# Convert RGB to LAB and extract the Blue channel
b = pcv.rgb2gray_lab(rgb_img=img, channel='b')
# Threshold the blue image
b_thresh = pcv.threshold.binary(gray_img=b,
threshold=160,
max_value=255,
object_type='light')
b_cnt = pcv.threshold.binary(gray_img=b,
threshold=160,
max_value=255,
object_type='light')
# Fill small objects
# b_fill = pcv.fill(b_thresh, 10)
# Join the thresholded saturation and blue-yellow images
bs = pcv.logical_or(bin_img1=s_mblur, bin_img2=b_cnt)
# Apply Mask (for VIS images, mask_color=white)
masked = pcv.apply_mask(img=img, mask=bs, mask_color='white')
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
cv2.imwrite("masked.jpeg", masked)
# Threshold the green-magenta and blue images
maskeda_thresh = pcv.threshold.binary(gray_img=masked_a,
threshold=115,
max_value=255,
object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(gray_img=masked_a,
threshold=135,
max_value=255,
object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b,
threshold=128,
max_value=255,
object_type='light')
# Join the thresholded saturation and blue-yellow images (OR)
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
# Fill small objects
ab_fill = pcv.fill(bin_img=ab, size=200)
# Apply mask (for VIS images, mask_color=white)
masked2 = pcv.apply_mask(img=masked, mask=ab_fill, mask_color='white')
cv2.imwrite("masked2.jpeg", masked2)
# Normalize the white color so you can later
# compare color between images.
# Inputs:
# img = image object, RGB color space
# roi = region for white reference, if none uses the whole image,
# otherwise (x position, y position, box width, box height)
# white balance image based on white toughspot
img1 = pcv.white_balance(crop_img, roi=(0, 0, 200, 20))
# In[109]:
# Convert RGB to HSV and extract the saturation channel
# Then set threshold for saturation
s = pcv.rgb2gray_hsv(rgb_img=img1, channel='s')
s_thresh = pcv.threshold.binary(gray_img=s,
threshold=122,
max_value=255,
object_type='dark')
# In[110]:
# Set Median Blur
#Input box size "ksize"
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=2)
s_cnt = pcv.median_blur(gray_img=s_thresh, ksize=2)
# In[111]:
# Convert RGB to LAB and extract the blue channel
def report_size_marker_area(img, roi_contour, roi_hierarchy, marker='define', objcolor='dark', thresh_channel=None,
thresh=None):
"""Detects a size marker in a specified region and reports its size and eccentricity
Inputs:
img = An RGB or grayscale image to plot the marker object on
roi_contour = A region of interest contour (e.g. output from pcv.roi.rectangle or other methods)
roi_hierarchy = A region of interest contour hierarchy (e.g. output from pcv.roi.rectangle or other methods)
marker = 'define' or 'detect'. If define it means you set an area, if detect it means you want to
detect within an area
objcolor = Object color is 'dark' or 'light' (is the marker darker or lighter than the background)
thresh_channel = 'h', 's', or 'v' for hue, saturation or value
thresh = Binary threshold value (integer)
Returns:
analysis_images = List of output images
:param img: numpy.ndarray
:param roi_contour: list
:param roi_hierarchy: numpy.ndarray
:param marker: str
:param objcolor: str
:param thresh_channel: str
:param thresh: int
:return: analysis_images: list
"""
params.device += 1
# Make a copy of the reference image
ref_img = np.copy(img)
# If the reference image is grayscale convert it to color
if len(np.shape(ref_img)) == 2:
ref_img = cv2.cvtColor(ref_img, cv2.COLOR_GRAY2BGR)
# Marker components
# If the marker type is "defined" then the marker_mask and marker_contours are equal to the input ROI
# Initialize a binary image
roi_mask = np.zeros(np.shape(img)[:2], dtype=np.uint8)
# Draw the filled ROI on the mask
cv2.drawContours(roi_mask, roi_contour, -1, (255), -1)
marker_mask = []
marker_contour = []
# If the marker type is "detect" then we will use the ROI to isolate marker contours from the input image
if marker.upper() == 'DETECT':
# We need to convert the input image into an one of the HSV channels and then threshold it
if thresh_channel is not None and thresh is not None:
# Mask the input image
masked = apply_mask(rgb_img=ref_img, mask=roi_mask, mask_color="black")
# Convert the masked image to hue, saturation, or value
marker_hsv = rgb2gray_hsv(rgb_img=masked, channel=thresh_channel)
# Threshold the HSV image
marker_bin = binary_threshold(gray_img=marker_hsv, threshold=thresh, max_value=255, object_type=objcolor)
# Identify contours in the masked image
contours, hierarchy = find_objects(img=ref_img, mask=marker_bin)
# Filter marker contours using the input ROI
kept_contours, kept_hierarchy, kept_mask, obj_area = roi_objects(img=ref_img, object_contour=contours,
obj_hierarchy=hierarchy,
roi_contour=roi_contour,
roi_hierarchy=roi_hierarchy,
roi_type="partial")
# If there are more than one contour detected, combine them into one
# These become the marker contour and mask
marker_contour, marker_mask = object_composition(img=ref_img, contours=kept_contours,
hierarchy=kept_hierarchy)
else:
fatal_error('thresh_channel and thresh must be defined in detect mode')
elif marker.upper() == "DEFINE":
# Identify contours in the masked image
contours, hierarchy = find_objects(img=ref_img, mask=roi_mask)
# If there are more than one contour detected, combine them into one
# These become the marker contour and mask
marker_contour, marker_mask = object_composition(img=ref_img, contours=contours, hierarchy=hierarchy)
else:
fatal_error("marker must be either 'define' or 'detect' but {0} was provided.".format(marker))
# Calculate the moments of the defined marker region
m = cv2.moments(marker_mask, binaryImage=True)
# Calculate the marker area
marker_area = m['m00']
# Fit a bounding ellipse to the marker
center, axes, angle = cv2.fitEllipse(marker_contour)
major_axis = np.argmax(axes)
minor_axis = 1 - major_axis
major_axis_length = axes[major_axis]
minor_axis_length = axes[minor_axis]
# Calculate the bounding ellipse eccentricity
eccentricity = np.sqrt(1 - (axes[minor_axis] / axes[major_axis]) ** 2)
# Make a list to store output images
analysis_image = []
cv2.drawContours(ref_img, marker_contour, -1, (255, 0, 0), 5)
# out_file = os.path.splitext(filename)[0] + '_sizemarker.jpg'
# print_image(ref_img, out_file)
analysis_image.append(ref_img)
if params.debug is 'print':
print_image(ref_img, os.path.join(params.debug_outdir, str(params.device) + '_marker_shape.png'))
elif params.debug is 'plot':
plot_image(ref_img)
outputs.add_observation(variable='marker_area', trait='marker area',
method='plantcv.plantcv.report_size_marker_area', scale='pixels', datatype=int,
value=marker_area, label='pixels')
outputs.add_observation(variable='marker_ellipse_major_axis', trait='marker ellipse major axis length',
method='plantcv.plantcv.report_size_marker_area', scale='pixels', datatype=int,
value=major_axis_length, label='pixels')
outputs.add_observation(variable='marker_ellipse_minor_axis', trait='marker ellipse minor axis length',
method='plantcv.plantcv.report_size_marker_area', scale='pixels', datatype=int,
value=minor_axis_length, label='pixels')
outputs.add_observation(variable='marker_ellipse_eccentricity', trait='marker ellipse eccentricity',
method='plantcv.plantcv.report_size_marker_area', scale='none', datatype=float,
value=eccentricity, label='none')
# Store images
outputs.images.append(analysis_image)
return analysis_image
def report_size_marker_area(img,
roi_contour,
roi_hierarchy,
marker='define',
objcolor='dark',
thresh_channel=None,
thresh=None):
"""Detects a size marker in a specified region and reports its size and eccentricity
Inputs:
img = An RGB or grayscale image to plot the marker object on
roi_contour = A region of interest contour (e.g. output from pcv.roi.rectangle or other methods)
roi_hierarchy = A region of interest contour hierarchy (e.g. output from pcv.roi.rectangle or other methods)
marker = 'define' or 'detect'. If define it means you set an area, if detect it means you want to
detect within an area
objcolor = Object color is 'dark' or 'light' (is the marker darker or lighter than the background)
thresh_channel = 'h', 's', or 'v' for hue, saturation or value
thresh = Binary threshold value (integer)
Returns:
analysis_images = List of output images
:param img: numpy.ndarray
:param roi_contour: list
:param roi_hierarchy: numpy.ndarray
:param marker: str
:param objcolor: str
:param thresh_channel: str
:param thresh: int
:return: analysis_images: list
"""
# Store debug
debug = params.debug
params.debug = None
params.device += 1
# Make a copy of the reference image
ref_img = np.copy(img)
# If the reference image is grayscale convert it to color
if len(np.shape(ref_img)) == 2:
ref_img = cv2.cvtColor(ref_img, cv2.COLOR_GRAY2BGR)
# Marker components
# If the marker type is "defined" then the marker_mask and marker_contours are equal to the input ROI
# Initialize a binary image
roi_mask = np.zeros(np.shape(img)[:2], dtype=np.uint8)
# Draw the filled ROI on the mask
cv2.drawContours(roi_mask, roi_contour, -1, (255), -1)
marker_mask = []
marker_contour = []
# If the marker type is "detect" then we will use the ROI to isolate marker contours from the input image
if marker.upper() == 'DETECT':
# We need to convert the input image into an one of the HSV channels and then threshold it
if thresh_channel is not None and thresh is not None:
# Mask the input image
masked = apply_mask(rgb_img=ref_img,
mask=roi_mask,
mask_color="black")
# Convert the masked image to hue, saturation, or value
marker_hsv = rgb2gray_hsv(rgb_img=masked, channel=thresh_channel)
# Threshold the HSV image
marker_bin = binary_threshold(gray_img=marker_hsv,
threshold=thresh,
max_value=255,
object_type=objcolor)
# Identify contours in the masked image
contours, hierarchy = find_objects(img=ref_img, mask=marker_bin)
# Filter marker contours using the input ROI
kept_contours, kept_hierarchy, kept_mask, obj_area = roi_objects(
img=ref_img,
object_contour=contours,
obj_hierarchy=hierarchy,
roi_contour=roi_contour,
roi_hierarchy=roi_hierarchy,
roi_type="partial")
# If there are more than one contour detected, combine them into one
# These become the marker contour and mask
marker_contour, marker_mask = object_composition(
img=ref_img, contours=kept_contours, hierarchy=kept_hierarchy)
else:
fatal_error(
'thresh_channel and thresh must be defined in detect mode')
elif marker.upper() == "DEFINE":
# Identify contours in the masked image
contours, hierarchy = find_objects(img=ref_img, mask=roi_mask)
# If there are more than one contour detected, combine them into one
# These become the marker contour and mask
marker_contour, marker_mask = object_composition(img=ref_img,
contours=contours,
hierarchy=hierarchy)
else:
fatal_error(
"marker must be either 'define' or 'detect' but {0} was provided.".
format(marker))
# Calculate the moments of the defined marker region
m = cv2.moments(marker_mask, binaryImage=True)
# Calculate the marker area
marker_area = m['m00']
# Fit a bounding ellipse to the marker
center, axes, angle = cv2.fitEllipse(marker_contour)
major_axis = np.argmax(axes)
minor_axis = 1 - major_axis
major_axis_length = axes[major_axis]
minor_axis_length = axes[minor_axis]
# Calculate the bounding ellipse eccentricity
eccentricity = np.sqrt(1 - (axes[minor_axis] / axes[major_axis])**2)
cv2.drawContours(ref_img, marker_contour, -1, (255, 0, 0), 5)
analysis_image = ref_img
# Reset debug mode
params.debug = debug
if params.debug is 'print':
print_image(
ref_img,
os.path.join(params.debug_outdir,
str(params.device) + '_marker_shape.png'))
elif params.debug is 'plot':
plot_image(ref_img)
outputs.add_observation(variable='marker_area',
trait='marker area',
method='plantcv.plantcv.report_size_marker_area',
scale='pixels',
datatype=int,
value=marker_area,
label='pixels')
outputs.add_observation(variable='marker_ellipse_major_axis',
trait='marker ellipse major axis length',
method='plantcv.plantcv.report_size_marker_area',
scale='pixels',
datatype=int,
value=major_axis_length,
label='pixels')
outputs.add_observation(variable='marker_ellipse_minor_axis',
trait='marker ellipse minor axis length',
method='plantcv.plantcv.report_size_marker_area',
scale='pixels',
datatype=int,
value=minor_axis_length,
label='pixels')
outputs.add_observation(variable='marker_ellipse_eccentricity',
trait='marker ellipse eccentricity',
method='plantcv.plantcv.report_size_marker_area',
scale='none',
datatype=float,
value=eccentricity,
label='none')
# Store images
outputs.images.append(analysis_image)
return analysis_image
def colorspaces(rgb_img, original_img=True):
""" Visualize an RGB image in all potential colorspaces
Inputs:
rgb_img = RGB image data
original_img = Whether or not to include the original image the the debugging plot
Returns:
plotting_img = Plotting image containing the original image and L,A,B,H,S, and V colorspaces
:param segmented_img: numpy.ndarray
:param original_img: bool
:return labeled_img: numpy.ndarray
"""
if not len(np.shape(rgb_img)) == 3:
fatal_error("Input image is not RGB!")
# Store and disable debug mode
debug = params.debug
params.debug = None
# Initialize grayscale images list, rgb images list, plotting coordinates
colorspace_names = ["H", "S", "V", "L", "A", "B"]
all_colorspaces = []
labeled_imgs = []
y = int(np.shape(rgb_img)[0] / 2)
x = int(np.shape(rgb_img)[1] / 2)
# Loop through and create grayscale imgs from each colorspace
for i in range(0, 3):
channel = colorspace_names[i]
all_colorspaces.append(rgb2gray_hsv(rgb_img=rgb_img, channel=channel))
for i in range(3, 6):
channel = colorspace_names[i]
all_colorspaces.append(rgb2gray_lab(rgb_img=rgb_img, channel=channel))
# Plot labels of each colorspace on the corresponding img
for i, colorspace in enumerate(all_colorspaces):
converted_img = cv2.cvtColor(colorspace, cv2.COLOR_GRAY2RGB)
labeled = cv2.putText(img=converted_img, text=colorspace_names[i], org=(x, y),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=params.text_size, color=(255, 0, 255), thickness=params.text_thickness)
labeled_imgs.append(labeled)
# Compile images together, including a larger version of the original image
plotting_img = np.vstack([np.hstack([labeled_imgs[0], labeled_imgs[1], labeled_imgs[2]]),
np.hstack([labeled_imgs[3], labeled_imgs[4], labeled_imgs[5]])])
# If original_img is True then also plot the original image with the rest of them
if original_img:
plotting_img = np.hstack([resize(img=rgb_img, resize_x=2, resize_y=2), plotting_img])
plotting_img = resize(plotting_img, resize_x=.5, resize_y=.5)
# Reset debug mode
params.debug = debug
if params.debug == "print":
# If debug is print, save the image to a file
print_image(plotting_img, os.path.join(params.debug_outdir, str(params.device) + "_vis_colorspaces.png"))
elif params.debug == "plot":
# If debug is plot, print to the plotting device
plot_image(plotting_img)
return plotting_img
def main():
# Get options
args = options()
if args.debug:
pcv.params.debug = args.debug # set debug mode
if args.debugdir:
pcv.params.debug_outdir = args.debugdir # set debug directory
os.makedirs(args.debugdir, exist_ok=True)
# pixel_resolution
# mm
# see pixel_resolution.xlsx for calibration curve for pixel to mm translation
pixelresolution = 0.052
# The result file should exist if plantcv-workflow.py was run
if os.path.exists(args.result):
# Open the result file
results = open(args.result, "r")
# The result file would have image metadata in it from plantcv-workflow.py, read it into memory
metadata = json.load(results)
# Close the file
results.close()
# Delete the file, we will create new ones
os.remove(args.result)
plantbarcode = metadata['metadata']['plantbarcode']['value']
print(plantbarcode,
metadata['metadata']['timestamp']['value'],
sep=' - ')
else:
# If the file did not exist (for testing), initialize metadata as an empty string
metadata = "{}"
regpat = re.compile(args.regex)
plantbarcode = re.search(regpat, args.image).groups()[0]
# read images and create mask
img, _, fn = pcv.readimage(args.image)
imagename = os.path.splitext(fn)[0]
# create mask
# taf=filters.try_all_threshold(s_img)
## remove background
s_img = pcv.rgb2gray_hsv(img, 's')
min_s = filters.threshold_minimum(s_img)
thresh_s = pcv.threshold.binary(s_img, min_s, 255, 'light')
rm_bkgrd = pcv.fill_holes(thresh_s)
## low greenness
thresh_s = pcv.threshold.binary(s_img, min_s + 15, 255, 'dark')
# taf = filters.try_all_threshold(s_img)
c = pcv.logical_xor(rm_bkgrd, thresh_s)
cinv = pcv.invert(c)
cinv_f = pcv.fill(cinv, 500)
cinv_f_c = pcv.closing(cinv_f, np.ones((5, 5)))
cinv_f_c_e = pcv.erode(cinv_f_c, 2, 1)
## high greenness
a_img = pcv.rgb2gray_lab(img, channel='a')
# taf = filters.try_all_threshold(a_img)
t_a = filters.threshold_isodata(a_img)
thresh_a = pcv.threshold.binary(a_img, t_a, 255, 'dark')
thresh_a = pcv.closing(thresh_a, np.ones((5, 5)))
thresh_a_f = pcv.fill(thresh_a, 500)
## combined mask
lor = pcv.logical_or(cinv_f_c_e, thresh_a_f)
close = pcv.closing(lor, np.ones((2, 2)))
fill = pcv.fill(close, 800)
erode = pcv.erode(fill, 3, 1)
fill2 = pcv.fill(erode, 1200)
# dilate = pcv.dilate(fill2,2,2)
mask = fill2
final_mask = np.zeros_like(mask)
# Compute greenness
# split color channels
b, g, r = cv2.split(img)
# print green intensity
# g_img = pcv.visualize.pseudocolor(g, cmap='Greens', background='white', min_value=0, max_value=255, mask=mask, axes=False)
# convert color channels to int16 so we can add them (values will be greater than 255 which is max of current uint8 format)
g = g.astype('uint16')
r = r.astype('uint16')
b = b.astype('uint16')
denom = g + r + b
# greenness index
out_flt = np.zeros_like(denom, dtype='float32')
# divide green by sum of channels to compute greenness index with values 0-1
gi = np.divide(g,
denom,
out=out_flt,
where=np.logical_and(denom != 0, mask > 0))
# find objects
c, h = pcv.find_objects(img, mask)
rc, rh = pcv.roi.multi(img, coord=[(1300, 900), (1300, 2400)], radius=350)
# Turn off debug temporarily, otherwise there will be a lot of plots
pcv.params.debug = None
# Loop over each region of interest
i = 0
rc_i = rc[i]
for i, rc_i in enumerate(rc):
rh_i = rh[i]
# Add ROI number to output. Before roi_objects so result has NA if no object.
pcv.outputs.add_observation(variable='roi',
trait='roi',
method='roi',
scale='int',
datatype=int,
value=i,
label='#')
roi_obj, hierarchy_obj, submask, obj_area = pcv.roi_objects(
img,
roi_contour=rc_i,
roi_hierarchy=rh_i,
object_contour=c,
obj_hierarchy=h,
roi_type='partial')
if obj_area == 0:
print('\t!!! No object found in ROI', str(i))
pcv.outputs.add_observation(
variable='plantarea',
trait='plant area in sq mm',
method='observations.area*pixelresolution^2',
scale=pixelresolution,
datatype="<class 'float'>",
value=0,
label='sq mm')
else:
# Combine multiple objects
# ple plant objects within an roi together
plant_object, plant_mask = pcv.object_composition(
img=img, contours=roi_obj, hierarchy=hierarchy_obj)
final_mask = pcv.image_add(final_mask, plant_mask)
# Save greenness for individual ROI
grnindex = np.mean(gi[np.where(plant_mask > 0)])
pcv.outputs.add_observation(
variable='greenness_index',
trait='mean normalized greenness index',
method='g/sum(b+g+r)',
scale='[0,1]',
datatype="<class 'float'>",
value=float(grnindex),
label='/1')
# Analyze all colors
hist = pcv.analyze_color(img, plant_mask, 'all')
# Analyze the shape of the current plant
shape_img = pcv.analyze_object(img, plant_object, plant_mask)
plant_area = pcv.outputs.observations['area'][
'value'] * pixelresolution**2
pcv.outputs.add_observation(
variable='plantarea',
trait='plant area in sq mm',
method='observations.area*pixelresolution^2',
scale=pixelresolution,
datatype="<class 'float'>",
value=plant_area,
label='sq mm')
# end if-else
# At this point we have observations for one plant
# We can write these out to a unique results file
# Here I will name the results file with the ROI ID combined with the original result filename
basename, ext = os.path.splitext(args.result)
filename = basename + "-roi" + str(i) + ext
# Save the existing metadata to the new file
with open(filename, "w") as r:
json.dump(metadata, r)
pcv.print_results(filename=filename)
# The results are saved, now clear out the observations so the next loop adds new ones for the next plant
pcv.outputs.clear()
if args.writeimg and obj_area != 0:
imgdir = os.path.join(args.outdir, 'shape_images', plantbarcode)
os.makedirs(imgdir, exist_ok=True)
pcv.print_image(
shape_img,
os.path.join(imgdir,
imagename + '-roi' + str(i) + '-shape.png'))
imgdir = os.path.join(args.outdir, 'colorhist_images',
plantbarcode)
os.makedirs(imgdir, exist_ok=True)
pcv.print_image(
hist,
os.path.join(imgdir,
imagename + '-roi' + str(i) + '-colorhist.png'))
# end roi loop
if args.writeimg:
# save grnness image of entire tray
imgdir = os.path.join(args.outdir, 'pseudocolor_images', plantbarcode)
os.makedirs(imgdir, exist_ok=True)
gi_img = pcv.visualize.pseudocolor(gi,
obj=None,
mask=final_mask,
cmap='viridis',
axes=False,
min_value=0.3,
max_value=0.6,
background='black',
obj_padding=0)
gi_img = add_scalebar(gi_img,
pixelresolution=pixelresolution,
barwidth=20,
barlocation='lower left')
gi_img.set_size_inches(6, 6, forward=False)
gi_img.savefig(os.path.join(imgdir, imagename + '-greenness.png'),
bbox_inches='tight')
gi_img.clf()
def plot_hotspots(directory, filename,convex_hull_flag):
# Read image
in_full_path = os.path.join(directory, filename)
img, path, filename = pcv.readimage(in_full_path, mode="rgb")
img_thermal = img.copy()
# Convert RGB to HSV and extract the saturation channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Threshold the saturation image
s_thresh = pcv.threshold.binary(gray_img=s, threshold=85, max_value=255, object_type='light')
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
edge = cv2.Canny(s_mblur, 60, 180)
outfile = 'Gray_' + filename
out_full_path = os.path.join(directory, outfile)
cv2.imwrite(out_full_path, edge)
# Contours extraction
contours, hierarchy = cv2.findContours(edge.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2:]
#contours = sorted(contours, key=cv2.contourArea, reverse=True)
hull_list = []
if (convex_hull_flag == True):
for i in range(len(contours)):
hull = cv2.convexHull(contours[i])
hull_list.append(hull)
contours = hull_list
mask = np.zeros(edge.shape, np.uint8)
hiers = hierarchy[0]
for i in range(len(contours)):
if hiers[i][3] != -1:
continue
cv2.drawContours(mask, contours, i,255, cv2.LINE_AA)
## Find all inner contours and draw
ch = hiers[i][2]
while ch != -1:
cv2.drawContours(mask, contours, ch, (255,0,255), -1, cv2.LINE_AA)
ch = hiers[ch][0]
thermal = thermal_image(img_thermal, mask)
if (convex_hull_flag == True):
outfile = 'Thermal_tree_CH_' + filename
else:
outfile = 'Thermal_tree_' + filename
out_full_path = os.path.join(directory, outfile)
cv2.imwrite(out_full_path, thermal)
centroids = []
if (convex_hull_flag == True):
area_threshold = 30
else:
area_threshold = 10
for i, cnt in enumerate(contours):
cv2.drawContours(mask, contours, i,255, cv2.FILLED)
if (cv2.contourArea(cnt) > area_threshold ):
moment = cv2.moments(contours[i])
Cx = int(moment["m10"]/moment["m00"])
Cy = int(moment["m01"]/moment["m00"])
center = (Cx, Cy)
centroids.append((contours, center, moment["m00"], 0))
#cv2.circle(img, (Cx, Cy), 5, (255, 255, 255), -1)
coordinate = '(' + str(Cx) + ',' + str(Cy) + ')'
cv2.putText(img, coordinate, (Cx,Cy), cv2.FONT_HERSHEY_SIMPLEX, 0.5, RED, 1, cv2.LINE_AA)
print(cv2.contourArea(cnt),Cx, Cy)
if Debug == True:
fig, ax = plt.subplots(1, figsize=(12,8))
plt.imshow(mask, cmap='Greys')
if (convex_hull_flag == True):
outfile = 'Hotspots_CH_' + filename
else:
outfile = 'Hotspots_' + filename
out_full_path = os.path.join(directory, outfile)
cv2.imwrite(out_full_path, img)
return
def generateMask(input, output, maskType=MASK_TYPES['BW']):
pcv.params.debug = True #set debug mode
# pcv.params.debug_outdir="./output.txt" #set output directory
# Read image (readimage mode defaults to native but if image is RGBA then specify mode='rgb')
# Inputs:
# filename - Image file to be read in
# mode - Return mode of image; either 'native' (default), 'rgb', 'gray', 'envi', or 'csv'
img, path, filename = pcv.readimage(filename=input, mode='rgb')
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Threshold the saturation image
s_thresh = pcv.threshold.binary(gray_img=s,
threshold=85,
max_value=255,
object_type='light')
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
s_cnt = pcv.median_blur(gray_img=s_thresh, ksize=5)
# Convert RGB to LAB and extract the Blue channel
b = pcv.rgb2gray_lab(rgb_img=img, channel='b')
# Threshold the blue image
b_thresh = pcv.threshold.binary(gray_img=b,
threshold=160,
max_value=255,
object_type='light')
b_cnt = pcv.threshold.binary(gray_img=b,
threshold=160,
max_value=255,
object_type='light')
# Fill small objects
# b_fill = pcv.fill(b_thresh, 10)
# Join the thresholded saturation and blue-yellow images
bs = pcv.logical_or(bin_img1=s_mblur, bin_img2=b_cnt)
# Apply Mask (for VIS images, mask_color=white)
masked = pcv.apply_mask(img=img, mask=bs, mask_color='white')
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
# Threshold the green-magenta and blue images
maskeda_thresh = pcv.threshold.binary(gray_img=masked_a,
threshold=115,
max_value=255,
object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(gray_img=masked_a,
threshold=135,
max_value=255,
object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b,
threshold=128,
max_value=255,
object_type='light')
# Join the thresholded saturation and blue-yellow images (OR)
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
if maskType == MASK_TYPES['BW']:
pcv.print_image(ab, filename=output)
return (True, None)
# Fill small objects
ab_fill = pcv.fill(bin_img=ab, size=200)
# Apply mask (for VIS images, mask_color=white)
masked2 = pcv.apply_mask(img=masked, mask=ab_fill, mask_color='black')
if maskType == MASK_TYPES['COLORED']:
pcv.print_image(masked2, filename=output)
return (True, None)
return (False, 'Unknown mask type.')
"""
def main():
# Get options
pcv.params.debug = args.debug #set debug mode
pcv.params.debug_outdir = args.outdir #set output directory
# Read image (readimage mode defaults to native but if image is RGBA then specify mode='rgb')
# Inputs:
# filename - Image file to be read in
# mode - Return mode of image; either 'native' (default), 'rgb', 'gray', or 'csv'
img, path, filename = pcv.readimage(filename=args.image, mode='rgb')
### SELECTING THE PLANT
### Attempt 5 combineren
# Parameters
hue_lower_tresh = 22 # 24
hue_higher_tresh = 50 # 50
saturation_lower_tresh = 138 # 140
saturation_higher_tresh = 230 # 230
value_lower_tresh = 120 # 125
value_higher_tresh = 255 # 255
# RGB color space
green_lower_tresh = 105 # 110
green_higher_tresh = 255 # 255
red_lower_tresh = 22 # 24
red_higher_thresh = 98 # 98
blue_lower_tresh = 85 # 85
blue_higher_tresh = 253 # 255
# CIELAB color space
#lab_blue_lower_tresh = 0 # Blue yellow channel
#lab_blue_higher_tresh = 255
s = pcv.rgb2gray_hsv(rgb_img=img, channel='h')
mask, masked_image = pcv.threshold.custom_range(
rgb_img=s,
lower_thresh=[hue_lower_tresh],
upper_thresh=[hue_higher_tresh],
channel='gray')
masked = pcv.apply_mask(rgb_img=img, mask=mask, mask_color='white')
# Filtered on Hue
s = pcv.rgb2gray_hsv(rgb_img=masked, channel='s')
mask, masked_image = pcv.threshold.custom_range(
rgb_img=s,
lower_thresh=[saturation_lower_tresh],
upper_thresh=[saturation_higher_tresh],
channel='gray')
masked = pcv.apply_mask(rgb_img=masked, mask=mask, mask_color='white')
#filtered on saturation
s = pcv.rgb2gray_hsv(rgb_img=masked, channel='v')
mask, masked_image = pcv.threshold.custom_range(
rgb_img=s,
lower_thresh=[value_lower_tresh],
upper_thresh=[value_higher_tresh],
channel='gray')
masked = pcv.apply_mask(rgb_img=masked, mask=mask, mask_color='white')
#filtered on value
mask, masked = pcv.threshold.custom_range(
rgb_img=masked,
lower_thresh=[0, green_lower_tresh, 0],
upper_thresh=[255, green_higher_tresh, 255],
channel='RGB')
masked = pcv.apply_mask(rgb_img=masked, mask=mask, mask_color='white')
#filtered on green
mask, masked = pcv.threshold.custom_range(
rgb_img=masked,
lower_thresh=[red_lower_tresh, 0, 0],
upper_thresh=[red_higher_thresh, 255, 255],
channel='RGB')
masked = pcv.apply_mask(rgb_img=masked, mask=mask, mask_color='white')
#filtered on red
mask_old, masked_old = pcv.threshold.custom_range(
rgb_img=masked,
lower_thresh=[0, 0, blue_lower_tresh],
upper_thresh=[255, 255, blue_higher_tresh],
channel='RGB')
masked = pcv.apply_mask(rgb_img=masked_old,
mask=mask_old,
mask_color='white')
#filtered on blue
#b = pcv.rgb2gray_lab(rgb_img = masked, channel = 'b') # Converting toe CIElab blue_yellow image
#b_thresh =pcv.threshold.binary(gray_img = b, threshold=lab_blue_lower_tresh, max_value = lab_blue_higher_tresh)
###_____________________________________ Now to identify objects
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
# Threshold the green-magenta and blue images
maskeda_thresh = pcv.threshold.binary(
gray_img=masked_a,
threshold=125, # original 115
max_value=255,
object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(
gray_img=masked_a,
threshold=140, # original 135
max_value=255,
object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b,
threshold=128,
max_value=255,
object_type='light')
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
# Fill small objects
# Inputs:
# bin_img - Binary image data
# size - Minimum object area size in pixels (must be an integer), and smaller objects will be filled
ab = pcv.median_blur(gray_img=ab, ksize=3)
ab_fill = pcv.fill(bin_img=ab, size=1000)
#print("filled")
# Apply mask (for VIS images, mask_color=white)
masked2 = pcv.apply_mask(rgb_img=masked, mask=ab_fill, mask_color='white')
# ID the objects
id_objects, obj_hierarchy = pcv.find_objects(masked2, ab_fill)
# Let's just take the largest
roi1, roi_hierarchy = pcv.roi.rectangle(img=masked2,
x=0,
y=0,
h=960,
w=1280) # Currently hardcoded
# Decide which objects to keep
# Inputs:
# img = img to display kept objects
# roi_contour = contour of roi, output from any ROI function
# roi_hierarchy = contour of roi, output from any ROI function
# object_contour = contours of objects, output from pcv.find_objects function
# obj_hierarchy = hierarchy of objects, output from pcv.find_objects function
# roi_type = 'partial' (default, for partially inside), 'cutto', or
# 'largest' (keep only largest contour)
with HiddenPrints():
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img=img,
roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type='partial')
# Object combine kept objects
# Inputs:
# img - RGB or grayscale image data for plotting
# contours - Contour list
# hierarchy - Contour hierarchy array
obj, mask = pcv.object_composition(img=img,
contours=roi_objects,
hierarchy=hierarchy3)
#print("final plant")
new_im = Image.fromarray(masked2)
new_im.save("output//" + args.filename + "last_masked.png")
##################_________________ Analysis
outfile = args.outdir + "/" + filename
# Here come all the analyse functions.
# pcv.acute_vertex(img, obj, 30, 15, 100)
color_img = pcv.analyze_color(rgb_img=img,
mask=kept_mask,
hist_plot_type=None)
#new_im = Image.fromarray(color_img)
#new_im.save(args.filename + "color_img.png")
# Find shape properties, output shape image (optional)
# Inputs:
# img - RGB or grayscale image data
# obj- Single or grouped contour object
# mask - Binary image mask to use as mask for moments analysis
shape_img = pcv.analyze_object(img=img, obj=obj, mask=mask)
new_im = Image.fromarray(shape_img)
new_im.save("output//" + args.filename + "shape_img.png")
# Shape properties relative to user boundary line (optional)
# Inputs:
# img - RGB or grayscale image data
# obj - Single or grouped contour object
# mask - Binary mask of selected contours
# line_position - Position of boundary line (a value of 0 would draw a line
# through the bottom of the image)
boundary_img1 = pcv.analyze_bound_horizontal(img=img,
obj=obj,
mask=mask,
line_position=1680)
new_im = Image.fromarray(boundary_img1)
new_im.save("output//" + args.filename + "boundary_img.png")
# Determine color properties: Histograms, Color Slices, output color analyzed histogram (optional)
# Inputs:
# rgb_img - RGB image data
# mask - Binary mask of selected contours
# hist_plot_type - None (default), 'all', 'rgb', 'lab', or 'hsv'
# This is the data to be printed to the SVG histogram file
color_histogram = pcv.analyze_color(rgb_img=img,
mask=kept_mask,
hist_plot_type='all')
#new_im = Image.fromarray(color_histogram)
#new_im.save(args.filename + "color_histogram_img.png")
# Pseudocolor the grayscale image
# Inputs:
# gray_img - Grayscale image data
# obj - Single or grouped contour object (optional), if provided the pseudocolored image gets
# cropped down to the region of interest.
# mask - Binary mask (optional)
# background - Background color/type. Options are "image" (gray_img, default), "white", or "black". A mask
# must be supplied.
# cmap - Colormap
# min_value - Minimum value for range of interest
# max_value - Maximum value for range of interest
# dpi - Dots per inch for image if printed out (optional, if dpi=None then the default is set to 100 dpi).
# axes - If False then the title, x-axis, and y-axis won't be displayed (default axes=True).
# colorbar - If False then the colorbar won't be displayed (default colorbar=True)
pseudocolored_img = pcv.visualize.pseudocolor(gray_img=s,
mask=kept_mask,
cmap='jet')
#new_im = Image.fromarray(pseudocolored_img)
#new_im.save(args.filename + "pseudocolored.png")
# Write shape and color data to results file
pcv.print_results(filename=args.result)
def iterate_rois(img, c, h, rc, rh, args, masked=True, gi=False, shape=False, hist=True, hue=False):
"""Analyze each ROI separately and store results
Parameters
----------
img : ndarray
rgb image
c : list
object contours
h : list
object countour hierarchy
rc : list
roi contours
rh : list
roi contour hierarchy
threshold_mask : ndarray
binary image (mask) from threshold steps
args : dict
commandline arguments and metadata from running the workflow
masked : boolean
whether to print masked rgb images for each roi
gi : boolean
whether to print greenness index false color
shape : boolean
whether to print object shapes on an image
hist : boolean
whether to print color histogram
hue : boolean
whether to save hsv color info and print the hue false color image
Returns
-------
binary image of plant mask that includes both threshold and roi filter steps : ndarray
"""
final_mask = np.zeros(shape=np.shape(img)[0:2], dtype='uint8')
# Compute greenness
if gi:
img_gi = cppc.compute.greenness_index(img=img, mask=final_mask+1)
if hue:
img_h = pcv.rgb2gray_hsv(img, 'h')
for i, rc_i in enumerate(rc):
rh_i = rh[i]
# Add ROI number to output. Before roi_objects so result has NA if no object.
pcv.outputs.add_observation(
sample='default',
variable='roi',
trait='roi',
method='roi',
scale='int',
datatype=int,
value=i,
label='#')
roi_obj, hierarchy_obj, submask, obj_area = pcv.roi_objects(
img, roi_contour=rc_i, roi_hierarchy=rh_i, object_contour=c, obj_hierarchy=h, roi_type='partial')
if obj_area == 0:
print('\t!!! No object found in ROI', str(i))
pcv.outputs.add_observation(
sample='default',
variable='plantarea',
trait='plant area in sq mm',
method='observations.area*pixelresolution^2',
scale=cppc.pixelresolution,
datatype="<class 'float'>",
value=0,
label='sq mm')
else:
# Combine multiple objects
# ple plant objects within an roi together
plant_object, plant_mask = pcv.object_composition(
img=img, contours=roi_obj, hierarchy=hierarchy_obj)
final_mask = pcv.image_add(final_mask, plant_mask)
if gi:
# Save greenness for individual ROI
grnindex = cppc.utils.mean(img_gi, plant_mask)
grnindexstd = cppc.utils.std(img_gi, plant_mask)
pcv.outputs.add_observation(
sample='default',
variable='greenness_index',
trait='mean normalized greenness index',
method='g/sum(b+g+r)',
scale='[0,1]',
datatype="<class 'float'>",
value=float(grnindex),
label='/1')
pcv.outputs.add_observation(
sample='default',
variable='greenness_index_std',
trait='std normalized greenness index',
method='g/sum(b+g+r)',
scale='[0,1]',
datatype="<class 'float'>",
value=float(grnindexstd),
label='/1')
# Analyze all colors
if hist:
colorhist = pcv.analyze_color(img, plant_mask, 'all')
elif hue:
_ = pcv.analyze_color(img, plant_mask, 'hsv')
# Analyze the shape of the current plant (always do this even if shape is False so you can get plant_area)
img_shape = pcv.analyze_object(img, plant_object, plant_mask)
plant_area = pcv.outputs.observations['default']['area']['value'] * cppc.pixelresolution**2
pcv.outputs.add_observation(
sample='default',
variable='plantarea',
trait='plant area in sq mm',
method='observations.area*pixelresolution^2',
scale=cppc.pixelresolution,
datatype="<class 'float'>",
value=plant_area,
label='sq mm')
# end if-else
# At this point we have observations for one plant
# We can write these out to a unique results file
write_output(args, i)
if args.writeimg and obj_area != 0:
if shape:
imgdir = os.path.join(args.outdir, 'shape_images', args.plantbarcode)
os.makedirs(imgdir, exist_ok=True)
pcv.print_image(img_shape, os.path.join(imgdir, args.imagename + '-roi' + str(i) + '-shape.png'))
if hist:
imgdir = os.path.join(args.outdir, 'colorhist_images', args.plantbarcode)
os.makedirs(imgdir, exist_ok=True)
pcv.print_image(colorhist, os.path.join(imgdir, args.imagename + '-roi' + str(i) + '-colorhist.png'))
if masked:
# save masked rgb image for entire tray but only 1 plant
imgdir = os.path.join(args.outdir, 'maskedrgb_images')
os.makedirs(imgdir, exist_ok=True)
img_masked = pcv.apply_mask(img, plant_mask, 'black')
pcv.print_image(
img_masked,
os.path.join(imgdir,
args.imagename + '-roi' + str(i) + '-masked.png'))
if hue:
# save hue false color image for entire tray but only 1 plant
imgdir = os.path.join(args.outdir, 'hue_images')
os.makedirs(imgdir, exist_ok=True)
fig_hue = pcv.visualize.pseudocolor(img_h*2, obj=None,
mask=plant_mask,
cmap=cppc.viz.get_cmap('hue'),
axes=False,
min_value=0, max_value=179,
background='black', obj_padding=0)
fig_hue = cppc.viz.add_scalebar(fig_hue,
pixelresolution=cppc.pixelresolution,
barwidth=10,
barlabel='1 cm',
barlocation='lower left')
fig_hue.set_size_inches(6, 6, forward=False)
fig_hue.savefig(os.path.join(imgdir, args.imagename + '-roi' + str(i) + '-hue.png'),
bbox_inches='tight',
dpi=300)
fig_hue.clf()
if gi:
# save grnness image of entire tray but only 1 plant
imgdir = os.path.join(args.outdir, 'grnindex_images')
os.makedirs(imgdir, exist_ok=True)
fig_gi = pcv.visualize.pseudocolor(img_gi,
obj=None,
mask=plant_mask,
cmap='viridis',
axes=False,
min_value=0.3,
max_value=0.6,
background='black',
obj_padding=0)
fig_gi = cppc.viz.add_scalebar(
fig_gi,
pixelresolution=cppc.pixelresolution,
barwidth=10,
barlabel='1 cm',
barlocation='lower left')
fig_gi.set_size_inches(6, 6, forward=False)
fig_gi.savefig(os.path.join(
imgdir,
args.imagename + '-roi' + str(i) + '-greenness.png'),
bbox_inches='tight',
dpi=300)
fig_gi.clf()
# end roi loop
return final_mask
def report_size_marker_area(img,
shape,
device,
debug,
marker='define',
x_adj=0,
y_adj=0,
w_adj=0,
h_adj=0,
base='white',
objcolor='dark',
thresh_channel=None,
thresh=None,
filename=False):
"""Outputs numeric properties for an input object (contour or grouped contours).
Inputs:
img = image object (most likely the original), color(RGB)
shape = 'rectangle', 'circle', 'ellipse'
device = device number. Used to count steps in the pipeline
debug = None, print, or plot. Print = save to file, Plot = print to screen.
marker = define or detect, if define it means you set an area, if detect it means you want to
detect within an area
x_adj = x position of shape, integer
y_adj = y position of shape, integer
w_adj = width
h_adj = height
plantcv = background color 'white' is default
objcolor = object color is 'dark' or 'light'
thresh_channel = 'h', 's','v'
thresh = integer value
filename = name of file
Returns:
device = device number
marker_header = shape data table headers
marker_data = shape data table values
analysis_images = list of output images
:param img: numpy array
:param shape: str
:param device: int
:param debug: str
:param marker: str
:param x_adj:int
:param y_adj:int
:param w_adj:int
:param h_adj:int
:param h_adj:int
:param base:str
:param objcolor: str
:param thresh_channel:str
:param thresh:int
:param filename: str
:return: device: int
:return: marker_header: str
:return: marker_data: int
:return: analysis_images: list
"""
device += 1
ori_img = np.copy(img)
if len(np.shape(img)) == 3:
ix, iy, iz = np.shape(img)
else:
ix, iy = np.shape(img)
size = ix, iy
roi_background = np.zeros(size, dtype=np.uint8)
roi_size = (ix - 5), (iy - 5)
roi = np.zeros(roi_size, dtype=np.uint8)
roi1 = roi + 1
roi_contour, roi_heirarchy = cv2.findContours(roi1, cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[-2:]
cv2.drawContours(roi_background, roi_contour[0], -1, (255, 0, 0), 5)
if (x_adj > 0 and w_adj > 0) or (y_adj > 0 and h_adj > 0):
fatal_error(
'Adjusted ROI position is out of frame, this will cause problems in detecting objects'
)
for cnt in roi_contour:
size1 = ix, iy, 3
background = np.zeros(size1, dtype=np.uint8)
if shape == 'rectangle' and (x_adj >= 0 and y_adj >= 0):
x, y, w, h = cv2.boundingRect(cnt)
x1 = x + x_adj
y1 = y + y_adj
w1 = w + w_adj
h1 = h + h_adj
cv2.rectangle(background, (x1, y1), (x + w1, y + h1), (1, 1, 1),
-1)
elif shape == 'circle':
x, y, w, h = cv2.boundingRect(cnt)
x1 = x + x_adj
y1 = y + y_adj
w1 = w + w_adj
h1 = h + h_adj
center = (int((w + x1) / 2), int((h + y1) / 2))
if h > w:
radius = int(w1 / 2)
cv2.circle(background, center, radius, (1, 1, 1), -1)
else:
radius = int(h1 / 2)
cv2.circle(background, center, radius, (1, 1, 1), -1)
elif shape == 'ellipse':
x, y, w, h = cv2.boundingRect(cnt)
x1 = x + x_adj
y1 = y + y_adj
w1 = w + w_adj
h1 = h + h_adj
center = (int((w + x1) / 2), int((h + y1) / 2))
if w > h:
cv2.ellipse(background, center, (int(w1 / 2), int(h1 / 2)), 0,
0, 360, (1, 1, 1), -1)
else:
cv2.ellipse(background, center, (int(h1 / 2), int(w1 / 2)), 0,
0, 360, (1, 1, 1), -1)
else:
fatal_error('Shape' + str(shape) +
' is not "rectangle", "circle", or "ellipse"!')
markerback = cv2.cvtColor(background, cv2.COLOR_RGB2GRAY)
shape_contour, hierarchy = cv2.findContours(markerback, cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[-2:]
cv2.drawContours(ori_img, shape_contour, -1, (255, 255, 0), 5)
if debug is 'print':
print_image(ori_img, (str(device) + '_marker_roi.png'))
elif debug is 'plot':
plot_image(ori_img)
if marker == 'define':
m = cv2.moments(markerback, binaryImage=True)
area = m['m00']
device, id_objects, obj_hierarchy = find_objects(
img, markerback, device, debug)
device, obj, mask = object_composition(img, id_objects, obj_hierarchy,
device, debug)
center, axes, angle = cv2.fitEllipse(obj)
major_axis = np.argmax(axes)
minor_axis = 1 - major_axis
major_axis_length = axes[major_axis]
minor_axis_length = axes[minor_axis]
eccentricity = np.sqrt(1 - (axes[minor_axis] / axes[major_axis])**2)
elif marker == 'detect':
if thresh_channel is not None and thresh is not None:
if base == 'white':
masked = cv2.multiply(img, background)
marker1 = markerback * 255
mask1 = cv2.bitwise_not(marker1)
markstack = np.dstack((mask1, mask1, mask1))
added = cv2.add(masked, markstack)
else:
added = cv2.multiply(img, background)
device, maskedhsv = rgb2gray_hsv(added, thresh_channel, device,
debug)
device, masked2a_thresh = binary_threshold(maskedhsv, thresh, 255,
objcolor, device, debug)
device, id_objects, obj_hierarchy = find_objects(
added, masked2a_thresh, device, debug)
device, roi1, roi_hierarchy = define_roi(added, shape, device,
None, 'default', debug,
True, x_adj, y_adj, w_adj,
h_adj)
device, roi_o, hierarchy3, kept_mask, obj_area = roi_objects(
img, 'partial', roi1, roi_hierarchy, id_objects, obj_hierarchy,
device, debug)
device, obj, mask = object_composition(img, roi_o, hierarchy3,
device, debug)
cv2.drawContours(ori_img,
roi_o,
-1, (0, 255, 0),
-1,
lineType=8,
hierarchy=hierarchy3)
m = cv2.moments(mask, binaryImage=True)
area = m['m00']
center, axes, angle = cv2.fitEllipse(obj)
major_axis = np.argmax(axes)
minor_axis = 1 - major_axis
major_axis_length = axes[major_axis]
minor_axis_length = axes[minor_axis]
eccentricity = np.sqrt(1 -
(axes[minor_axis] / axes[major_axis])**2)
else:
fatal_error(
'thresh_channel and thresh must be defined in detect mode')
else:
fatal_error("marker must be either in 'detect' or 'define' mode")
analysis_images = []
if filename:
out_file = str(filename[0:-4]) + '_sizemarker.jpg'
print_image(ori_img, out_file)
analysis_images.append(['IMAGE', 'marker', out_file])
if debug is 'print':
print_image(ori_img, (str(device) + '_marker_shape.png'))
elif debug is 'plot':
plot_image(ori_img)
marker_header = ('HEADER_MARKER', 'marker_area',
'marker_major_axis_length', 'marker_minor_axis_length',
'marker_eccentricity')
marker_data = ('MARKER_DATA', area, major_axis_length, minor_axis_length,
eccentricity)
return device, marker_header, marker_data, analysis_images
DATA_DIR = ''
for image in os.listdir(DATA_DIR):
# Read Image
image = cv2.imread(DATA_DIR + "/" + image)
# Prompt the user to select the region of interest
roi = cv2.selectROI(image)
# Collect the cropped image
cropped_img = image[int(roi[1]):int(roi[1] + roi[3]),
int(roi[0]):int(roi[0] + roi[2])]
# Convert RGB to HSV and extract saturation channel
# The HSV value can be changed to be h, s, or v depending on the colour of the flower
saturation_img = pcv.rgb2gray_hsv(cropped_img, 'h')
# Threshold the saturation img
# Depending on the output of the saturation image, the value can be light or dark
# Light or dark is what defines what part of the image its to be removed
saturation_thresh = pcv.threshold.binary(saturation_img, 85, 255, 'light')
# Apply median blur
saturation_mblur = pcv.median_blur(saturation_thresh, 5)
# Convert RGB to LAB and extract blue channel
# Like the HSV function this can be l, a, or b depending on the colour of the flower
blue_channel_img = pcv.rgb2gray_lab(cropped_img, 'l')
blue_channel_cnt = pcv.threshold.binary(blue_channel_img, 160, 255,
'light')
def silhouette_top():
"First we draw the picture from the 3D data"
########################################################################################################################################################################
x = []
y = []
z = []
image_top = Image.new("RGB", (width, height), color='white')
draw = ImageDraw.Draw(image_top)
data_3d = open(args.image, "r")
orignal_file = args.image
for line in data_3d:
line = line.split(",")
y.append(int(line[0]))
x.append(int(line[1]))
z.append(int(line[2]))
i = 0
for point_x in x:
point_y = y[i]
draw.rectangle([point_x, point_y, point_x + 1, point_y + 1],
fill="black")
#rectange takes input [x0, y0, x1, y1]
i += 1
image_top.save("top_temp.png")
image_side = Image.new("RGB", (1280, 960), color='white')
draw = ImageDraw.Draw(image_side)
i = 0
for point_y in y:
point_z = z[i]
draw.rectangle([point_z, point_y, point_z + 1, point_y + 1],
fill="black")
#rectange takes input [x0, y0, x1, y1]
i += 1
image_side.save("side_temp.png")
########################################################################################################################################################################
args.image = "top_temp.png"
# Get options
pcv.params.debug = args.debug #set debug mode
pcv.params.debug_outdir = args.outdir #set output directory
pcv.params.debug = args.debug # set debug mode
pcv.params.debug_outdir = args.outdir # set output directory
# Read image
img, path, filename = pcv.readimage(filename=args.image)
v = pcv.rgb2gray_hsv(rgb_img=img, channel='v')
v_thresh, maskedv_image = pcv.threshold.custom_range(rgb_img=v,
lower_thresh=[0],
upper_thresh=[200],
channel='gray')
id_objects, obj_hierarchy = pcv.find_objects(img=maskedv_image,
mask=v_thresh)
# Define ROI
roi1, roi_hierarchy = pcv.roi.rectangle(img=maskedv_image,
x=0,
y=0,
h=height,
w=width)
# Decide which objects to keep
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img=img,
roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type='partial')
obj, mask = pcv.object_composition(img=img,
contours=roi_objects,
hierarchy=hierarchy3)
outfile = args.outdir + "/" + filename
# Shape properties relative to user boundary line (optional)
boundary_img1 = pcv.analyze_bound_horizontal(img=img,
obj=obj,
mask=mask,
line_position=1680)
new_im = Image.fromarray(boundary_img1)
new_im.save("output//" + args.filename + "_top_boundary.png")
# Find shape properties, output shape image (optional)
shape_img = pcv.analyze_object(img=img, obj=obj, mask=mask)
new_im = Image.fromarray(shape_img)
new_im.save("output//" + args.filename + "_top_shape.png")
new_im.save("output//" + args.filename + "shape_img.png")
GT = re.sub(pattern, replacement, files_names[file_counter])
pcv.outputs.add_observation(variable="genotype",
trait="genotype",
method="Regexed from the filename",
scale=None,
datatype=str,
value=int(GT),
label="GT")
# Write shape and color data to results file
pcv.print_results(filename=args.result)
##########################################################################################################################################
args.image = "side_temp.png"
# Get options
pcv.params.debug = args.debug #set debug mode
pcv.params.debug_outdir = args.outdir #set output directory
pcv.params.debug = args.debug # set debug mode
pcv.params.debug_outdir = args.outdir # set output directory
# Read image
img, path, filename = pcv.readimage(filename=args.image)
v = pcv.rgb2gray_hsv(rgb_img=img, channel='v')
v_thresh, maskedv_image = pcv.threshold.custom_range(rgb_img=v,
lower_thresh=[0],
upper_thresh=[200],
channel='gray')
id_objects, obj_hierarchy = pcv.find_objects(img=maskedv_image,
mask=v_thresh)
# Define ROI
roi1, roi_hierarchy = pcv.roi.rectangle(img=maskedv_image,
x=0,
y=0,
h=height,
w=width)
# Decide which objects to keep
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img=img,
roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type='partial')
obj, mask = pcv.object_composition(img=img,
contours=roi_objects,
hierarchy=hierarchy3)
outfile = args.outdir + "/" + filename
# Shape properties relative to user boundary line (optional)
boundary_img1 = pcv.analyze_bound_horizontal(img=img,
obj=obj,
mask=mask,
line_position=1680)
new_im = Image.fromarray(boundary_img1)
new_im.save("output//" + args.filename + "_side_boundary.png")
# Find shape properties, output shape image (optional)
shape_img = pcv.analyze_object(img=img, obj=obj, mask=mask)
new_im = Image.fromarray(shape_img)
new_im.save("output//" + args.filename + "_side_shape.png")
GT = re.sub(pattern, replacement, files_names[file_counter])
pcv.outputs.add_observation(variable="genotype",
trait="genotype",
method="Regexed from the filename",
scale=None,
datatype=str,
value=int(GT),
label="GT")
# Write shape and color data to results file
pcv.print_results(filename=args.result_side)
def main():
# Get options
args = options()
# Set variables
device = 0
pcv.params.debug = args.debug
img_file = args.image
# Read image
img, path, filename = pcv.readimage(filename=img_file, mode='rgb')
# Process saturation channel from HSV colour space
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
lp_s = pcv.laplace_filter(s, 1, 1)
shrp_s = pcv.image_subtract(s, lp_s)
s_eq = pcv.hist_equalization(shrp_s)
s_thresh = pcv.threshold.binary(gray_img=s_eq,
threshold=215,
max_value=255,
object_type='light')
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
# Process green-magenta channel from LAB colour space
b = pcv.rgb2gray_lab(rgb_img=img, channel='a')
b_lp = pcv.laplace_filter(b, 1, 1)
b_shrp = pcv.image_subtract(b, b_lp)
b_thresh = pcv.threshold.otsu(b_shrp, 255, object_type='dark')
# Create and apply mask
bs = pcv.logical_or(bin_img1=s_mblur, bin_img2=b_thresh)
filled = pcv.fill_holes(bs)
masked = pcv.apply_mask(img=img, mask=filled, mask_color='white')
# Extract colour channels from masked image
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
# Threshold the green-magenta and blue images
maskeda_thresh = pcv.threshold.binary(gray_img=masked_a,
threshold=115,
max_value=255,
object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(gray_img=masked_a,
threshold=140,
max_value=255,
object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b,
threshold=128,
max_value=255,
object_type='light')
# Join the thresholded saturation and blue-yellow images (OR)
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
# Produce and apply a mask
opened_ab = pcv.opening(gray_img=ab)
ab_fill = pcv.fill(bin_img=ab, size=200)
closed_ab = pcv.closing(gray_img=ab_fill)
masked2 = pcv.apply_mask(img=masked, mask=bs, mask_color='white')
# Identify objects
id_objects, obj_hierarchy = pcv.find_objects(img=masked2, mask=ab_fill)
# Define region of interest (ROI)
roi1, roi_hierarchy = pcv.roi.rectangle(img=masked2,
x=250,
y=100,
h=200,
w=200)
# Decide what objects to keep
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(
img=img,
roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type='partial')
# Object combine kept objects
obj, mask = pcv.object_composition(img=img,
contours=roi_objects,
hierarchy=hierarchy3)
############### Analysis ################
outfile = False
if args.writeimg == True:
outfile = args.outdir + "/" + filename
# Analyze the plant
analysis_image = pcv.analyze_object(img=img, obj=obj, mask=mask)
color_histogram = pcv.analyze_color(rgb_img=img,
mask=kept_mask,
hist_plot_type='all')
top_x, bottom_x, center_v_x = pcv.x_axis_pseudolandmarks(img=img,
obj=obj,
mask=mask)
top_y, bottom_y, center_v_y = pcv.y_axis_pseudolandmarks(img=img,
obj=obj,
mask=mask)
# Print results of the analysis
pcv.print_results(filename=args.result)
pcv.output_mask(img,
kept_mask,
filename,
outdir=args.outdir,
mask_only=True)
def test(true_positive_file, test_parameters):
hue_lower_tresh = test_parameters[0]
hue_higher_tresh = test_parameters[1]
saturation_lower_tresh = test_parameters[2]
saturation_higher_tresh = test_parameters[3]
value_lower_tresh = test_parameters[4]
value_higher_tresh = test_parameters[5]
green_lower_tresh = test_parameters[6]
green_higher_tresh = test_parameters[7]
red_lower_tresh = test_parameters[8]
red_higher_thresh = test_parameters[9]
blue_lower_tresh = test_parameters[10]
blue_higher_tresh = test_parameters[11]
blur_k = test_parameters[12]
fill_k = test_parameters[13]
class args:
#image = "C:\\Users\\RensD\\OneDrive\\studie\\Master\\The_big_project\\top_perspective\\0214_2018-03-07 08.55 - 26_cam9.png"
image = true_positive_file
outdir = "C:\\Users\\RensD\\OneDrive\\studie\\Master\\The_big_project\\top_perspective\\output"
debug = debug_setting
result = "results.txt"
# Get options
pcv.params.debug=args.debug #set debug mode
pcv.params.debug_outdir=args.outdir #set output directory
# Read image (readimage mode defaults to native but if image is RGBA then specify mode='rgb')
# Inputs:
# filename - Image file to be read in
# mode - Return mode of image; either 'native' (default), 'rgb', 'gray', or 'csv'
img, path, filename = pcv.readimage(filename=args.image, mode='rgb')
s = pcv.rgb2gray_hsv(rgb_img=img, channel='h')
mask, masked_image = pcv.threshold.custom_range(rgb_img=s, lower_thresh=[hue_lower_tresh], upper_thresh=[hue_higher_tresh], channel='gray')
masked = pcv.apply_mask(rgb_img=img, mask = mask, mask_color = 'white')
#print("filtered on hue")
s = pcv.rgb2gray_hsv(rgb_img=masked, channel='s')
mask, masked_image = pcv.threshold.custom_range(rgb_img=s, lower_thresh=[saturation_lower_tresh], upper_thresh=[saturation_higher_tresh], channel='gray')
masked = pcv.apply_mask(rgb_img=masked, mask = mask, mask_color = 'white')
#print("filtered on saturation")
s = pcv.rgb2gray_hsv(rgb_img=masked, channel='v')
mask, masked_image = pcv.threshold.custom_range(rgb_img=s, lower_thresh=[value_lower_tresh], upper_thresh=[value_higher_tresh], channel='gray')
masked = pcv.apply_mask(rgb_img=masked, mask = mask, mask_color = 'white')
#print("filtered on value")
mask, masked = pcv.threshold.custom_range(rgb_img=masked, lower_thresh=[0,green_lower_tresh,0], upper_thresh=[255,green_higher_tresh,255], channel='RGB')
masked = pcv.apply_mask(rgb_img=masked, mask = mask, mask_color = 'white')
#print("filtered on green")
mask, masked = pcv.threshold.custom_range(rgb_img=masked, lower_thresh=[red_lower_tresh,0,0], upper_thresh=[red_higher_thresh,255,255], channel='RGB')
masked = pcv.apply_mask(rgb_img=masked, mask = mask, mask_color = 'white')
#print("filtered on red")
mask_old, masked_old = pcv.threshold.custom_range(rgb_img=masked, lower_thresh=[0,0,blue_lower_tresh], upper_thresh=[255,255,blue_higher_tresh], channel='RGB')
masked = pcv.apply_mask(rgb_img=masked_old, mask = mask_old, mask_color = 'white')
#print("filtered on blue")
###____________________________________ Blur to minimize
try:
s_mblur = pcv.median_blur(gray_img = masked_old, ksize = blur_k)
s = pcv.rgb2gray_hsv(rgb_img=s_mblur, channel='v')
mask, masked_image = pcv.threshold.custom_range(rgb_img=s, lower_thresh=[0], upper_thresh=[254], channel='gray')
except:
print("failed blur step")
try:
mask = pcv.fill(mask, fill_k)
except:
pass
masked = pcv.apply_mask(rgb_img=masked, mask = mask, mask_color = 'white')
###_____________________________________ Now to identify objects
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
# Threshold the green-magenta and blue images
maskeda_thresh = pcv.threshold.binary(gray_img=masked_a, threshold=115,
max_value=255, object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(gray_img=masked_a, threshold=135,
max_value=255, object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b, threshold=128,
max_value=255, object_type='light')
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
# Fill small objects
# Inputs:
# bin_img - Binary image data
# size - Minimum object area size in pixels (must be an integer), and smaller objects will be filled
ab_fill = pcv.fill(bin_img=ab, size=200)
#print("filled")
# Apply mask (for VIS images, mask_color=white)
masked2 = pcv.apply_mask(rgb_img=masked, mask=ab_fill, mask_color='white')
id_objects, obj_hierarchy = pcv.find_objects(masked, ab_fill)
# Let's just take the largest
roi1, roi_hierarchy= pcv.roi.rectangle(img=masked, x=0, y=0, h=960, w=1280) # Currently hardcoded
with HiddenPrints():
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img=img, roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type=roi_type)
obj, mask = pcv.object_composition(img=img, contours=roi_objects, hierarchy=hierarchy3)
if use_mask == True:
return(mask)
else:
masked2 = pcv.apply_mask(rgb_img=masked, mask=mask, mask_color='white')
return(masked2)
def segmentation(imgW, imgNIR, shape):
# VIS example from PlantCV with few modifications
# Higher value = more strict selection
s_threshold = 165
b_threshold = 200
# Read image
img = imread(imgW)
#img = cvtColor(img, COLOR_BGR2RGB)
imgNIR = imread(imgNIR)
#imgNIR = cvtColor(imgNIR, COLOR_BGR2RGB)
#img, path, img_filename = pcv.readimage(filename=imgW, mode="native")
#imgNIR, pathNIR, imgNIR_filename = pcv.readimage(filename=imgNIR, mode="native")
# Convert RGB to HSV and extract the saturation channel
s = pcv.rgb2gray_hsv(rgb_img=img, channel='s')
# Threshold the saturation image
s_thresh = pcv.threshold.binary(gray_img=s, threshold=s_threshold, max_value=255, object_type='light')
# Median Blur
s_mblur = pcv.median_blur(gray_img=s_thresh, ksize=5)
s_cnt = pcv.median_blur(gray_img=s_thresh, ksize=5)
# Convert RGB to LAB and extract the Blue channel
b = pcv.rgb2gray_lab(rgb_img=img, channel='b')
# Threshold the blue image ORIGINAL 160
b_thresh = pcv.threshold.binary(gray_img=b, threshold=b_threshold, max_value=255, object_type='light')
b_cnt = pcv.threshold.binary(gray_img=b, threshold=b_threshold, max_value=255, object_type='light')
# Join the thresholded saturation and blue-yellow images
bs = pcv.logical_or(bin_img1=s_mblur, bin_img2=b_cnt)
# Apply Mask (for VIS images, mask_color=white)
masked = pcv.apply_mask(img=img, mask=bs, mask_color='white')
# Convert RGB to LAB and extract the Green-Magenta and Blue-Yellow channels
masked_a = pcv.rgb2gray_lab(rgb_img=masked, channel='a')
masked_b = pcv.rgb2gray_lab(rgb_img=masked, channel='b')
# Threshold the green-magenta and blue images
# 115
# 135
# 128
maskeda_thresh = pcv.threshold.binary(gray_img=masked_a, threshold=115, max_value=255, object_type='dark')
maskeda_thresh1 = pcv.threshold.binary(gray_img=masked_a, threshold=135, max_value=255, object_type='light')
maskedb_thresh = pcv.threshold.binary(gray_img=masked_b, threshold=128, max_value=255, object_type='light')
# Join the thresholded saturation and blue-yellow images (OR)
ab1 = pcv.logical_or(bin_img1=maskeda_thresh, bin_img2=maskedb_thresh)
ab = pcv.logical_or(bin_img1=maskeda_thresh1, bin_img2=ab1)
# Fill small objects
ab_fill = pcv.fill(bin_img=ab, size=200)
# Apply mask (for VIS images, mask_color=white)
masked2 = pcv.apply_mask(img=masked, mask=ab_fill, mask_color='white')
# Identify objects
id_objects, obj_hierarchy = pcv.find_objects(img=masked2, mask=ab_fill)
# Define ROI
height = shape[0]
width = shape[1]
roi1, roi_hierarchy= pcv.roi.rectangle(img=masked2, x=0, y=0, h=height, w=width)
# Decide which objects to keep
roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img=img, roi_contour=roi1,
roi_hierarchy=roi_hierarchy,
object_contour=id_objects,
obj_hierarchy=obj_hierarchy,
roi_type='partial')
# Object combine kept objects
obj, mask = pcv.object_composition(img=img, contours=roi_objects, hierarchy=hierarchy3)
# Filling holes in the mask, works great for alive plants, not so good for dead plants
filled_mask = pcv.fill_holes(mask)
final = pcv.apply_mask(img=imgNIR, mask=mask, mask_color='white')
pcv.print_image(final, "./segment/segment-temp.png")
def main():
# create options object for argument parsing
args = options()
# set device
device = 0
# set debug
pcv.params.debug = args.debug
outfile = False
if args.writeimg:
outfile = os.path.join(args.outdir, os.path.basename(args.image)[:-4])
# read in image
img, path, filename = pcv.readimage(filename=args.image, debug=args.debug)
# read in a background image for each zoom level
config_file = open(args.bkg, 'r')
config = json.load(config_file)
config_file.close()
if "z1500" in args.image:
bkg_image = config["z1500"]
elif "z2500" in args.image:
bkg_image = config["z2500"]
else:
pcv.fatal_error("Image {0} has an unsupported zoom level.".format(args.image))
bkg, bkg_path, bkg_filename = pcv.readimage(filename=bkg_image, debug=args.debug)
# Detect edges in the background image
device, bkg_sat = pcv.rgb2gray_hsv(img=bkg, channel="s", device=device, debug=args.debug)
device += 1
bkg_edges = feature.canny(bkg_sat)
if args.debug == "print":
pcv.print_image(img=bkg_edges, filename=str(device) + '_background_edges.png')
elif args.debug == "plot":
pcv.plot_image(img=bkg_edges, cmap="gray")
# Close background edge contours
bkg_edges_closed = ndi.binary_closing(bkg_edges)
device += 1
if args.debug == "print":
pcv.print_image(img=bkg_edges_closed, filename=str(device) + '_closed_background_edges.png')
elif args.debug == "plot":
pcv.plot_image(img=bkg_edges_closed, cmap="gray")
# Fill in closed contours in background
bkg_fill_contours = ndi.binary_fill_holes(bkg_edges_closed)
device += 1
if args.debug == "print":
pcv.print_image(img=bkg_fill_contours, filename=str(device) + '_filled_background_edges.png')
elif args.debug == "plot":
pcv.plot_image(img=bkg_fill_contours, cmap="gray")
# Naive Bayes image classification/segmentation
device, mask = pcv.naive_bayes_classifier(img=img, pdf_file=args.pdf, device=device, debug=args.debug)
# Do a light cleaning of the plant mask to remove small objects
cleaned = morphology.remove_small_objects(mask["plant"].astype(bool), 2)
device += 1
if args.debug == "print":
pcv.print_image(img=cleaned, filename=str(device) + '_cleaned_mask.png')
elif args.debug == "plot":
pcv.plot_image(img=cleaned, cmap="gray")
# Convert the input image to a saturation channel grayscale image
device, sat = pcv.rgb2gray_hsv(img=img, channel="s", device=device, debug=args.debug)
# Detect edges in the saturation image
edges = feature.canny(sat)
device += 1
if args.debug == "print":
pcv.print_image(img=edges, filename=str(device) + '_plant_edges.png')
elif args.debug == "plot":
pcv.plot_image(img=edges, cmap="gray")
# Combine pixels that are in both foreground edges and the filled background edges
device, combined_bkg = pcv.logical_and(img1=edges.astype(np.uint8) * 255,
img2=bkg_fill_contours.astype(np.uint8) * 255, device=device,
debug=args.debug)
# Remove background pixels from the foreground edges
device += 1
filtered = np.copy(edges)
filtered[np.where(combined_bkg == 255)] = False
if args.debug == "print":
pcv.print_image(img=filtered, filename=str(device) + '_filtered_edges.png')
elif args.debug == "plot":
pcv.plot_image(img=filtered, cmap="gray")
# Combine the cleaned naive Bayes mask and the filtered foreground edges
device += 1
combined = cleaned + filtered
if args.debug == "print":
pcv.print_image(img=combined, filename=str(device) + '_combined_foreground.png')
elif args.debug == "plot":
pcv.plot_image(img=combined, cmap="gray")
# Close off broken edges and other incomplete contours
device += 1
closed_features = ndi.binary_closing(combined, structure=np.ones((3, 3)))
if args.debug == "print":
pcv.print_image(img=closed_features, filename=str(device) + '_closed_features.png')
elif args.debug == "plot":
pcv.plot_image(img=closed_features, cmap="gray")
# Fill in holes in contours
# device += 1
# fill_contours = ndi.binary_fill_holes(closed_features)
# if args.debug == "print":
# pcv.print_image(img=fill_contours, filename=str(device) + '_filled_contours.png')
# elif args.debug == "plot":
# pcv.plot_image(img=fill_contours, cmap="gray")
# Use median blur to break horizontal and vertical thin edges (pot edges)
device += 1
blurred_img = ndi.median_filter(closed_features.astype(np.uint8) * 255, (3, 1))
blurred_img = ndi.median_filter(blurred_img, (1, 3))
# Remove small objects left behind by blurring
cleaned2 = morphology.remove_small_objects(blurred_img.astype(bool), 200)
if args.debug == "print":
pcv.print_image(img=cleaned2, filename=str(device) + '_cleaned_by_median_blur.png')
elif args.debug == "plot":
pcv.plot_image(img=cleaned2, cmap="gray")
# Define region of interest based on camera zoom level for masking the naive Bayes classified image
# if "z1500" in args.image:
# h = 1000
# elif "z2500" in args.image:
# h = 1050
# else:
# pcv.fatal_error("Image {0} has an unsupported zoom level.".format(args.image))
# roi, roi_hierarchy = pcv.roi.rectangle(x=300, y=150, w=1850, h=h, img=img)
# Mask the classified image to remove noisy areas prior to finding contours
# side_mask = np.zeros(np.shape(img)[:2], dtype=np.uint8)
# cv2.drawContours(side_mask, roi, -1, (255), -1)
# device, masked_img = pcv.apply_mask(img=cv2.merge([mask["plant"], mask["plant"], mask["plant"]]), mask=side_mask,
# mask_color="black", device=device, debug=args.debug)
# Convert the masked image back to grayscale
# masked_img = masked_img[:, :, 0]
# Close off contours at the base of the plant
# if "z1500" in args.image:
# pt1 = (1100, 1118)
# pt2 = (1340, 1120)
# elif "z2500" in args.image:
# pt1 = (1020, 1162)
# pt2 = (1390, 1166)
# else:
# pcv.fatal_error("Image {0} has an unsupported zoom level.".format(args.image))
# masked_img = cv2.rectangle(np.copy(masked_img), pt1, pt2, (255), -1)
# closed_mask = ndi.binary_closing(masked_img.astype(bool), iterations=3)
# Find objects in the masked naive Bayes mask
# device, objects, obj_hierarchy = pcv.find_objects(img=img, mask=np.copy(masked_img), device=device,
# debug=args.debug)
# objects, obj_hierarchy = cv2.findContours(np.copy(closed_mask.astype(np.uint8) * 255), cv2.RETR_CCOMP,
# cv2.CHAIN_APPROX_NONE)[-2:]
# Clean up the combined plant edges/mask image by removing filled in gaps/holes
# device += 1
# cleaned3 = np.copy(cleaned2)
# cleaned3 = cleaned3.astype(np.uint8) * 255
# # Loop over the contours from the naive Bayes mask
# for c, contour in enumerate(objects):
# # Calculate the area of each contour
# # area = cv2.contourArea(contour)
# # If the contour is a hole (i.e. it has no children and it has a parent)
# # And it is not a small hole in a leaf that was not classified
# if obj_hierarchy[0][c][2] == -1 and obj_hierarchy[0][c][3] > -1:
# # Then fill in the contour (hole) black on the cleaned mask
# cv2.drawContours(cleaned3, objects, c, (0), -1, hierarchy=obj_hierarchy)
# if args.debug == "print":
# pcv.print_image(img=cleaned3, filename=str(device) + '_gaps_removed.png')
# elif args.debug == "plot":
# pcv.plot_image(img=cleaned3, cmap="gray")
# Find contours using the cleaned mask
device, contours, contour_hierarchy = pcv.find_objects(img=img, mask=np.copy(cleaned2.astype(np.uint8)),
device=device, debug=args.debug)
# Define region of interest based on camera zoom level for contour filtering
if "z1500" in args.image:
h = 940
elif "z2500" in args.image:
h = 980
else:
pcv.fatal_error("Image {0} has an unsupported zoom level.".format(args.image))
roi, roi_hierarchy = pcv.roi.rectangle(x=300, y=150, w=1850, h=h, img=img)
# Filter contours in the region of interest
device, roi_objects, hierarchy, kept_mask, obj_area = pcv.roi_objects(img=img, roi_type='partial', roi_contour=roi,
roi_hierarchy=roi_hierarchy,
object_contour=contours,
obj_hierarchy=contour_hierarchy,
device=device, debug=args.debug)
# Analyze only images with plants present
if len(roi_objects) > 0:
# Object combine kept objects
device, plant_contour, plant_mask = pcv.object_composition(img=img, contours=roi_objects, hierarchy=hierarchy,
device=device, debug=args.debug)
if args.writeimg:
# Save the plant mask if requested
pcv.print_image(img=plant_mask, filename=outfile + "_mask.png")
# Find shape properties, output shape image
device, shape_header, shape_data, shape_img = pcv.analyze_object(img=img, imgname=args.image, obj=plant_contour,
mask=plant_mask, device=device,
debug=args.debug,
filename=outfile)
# Set the boundary line based on the camera zoom level
if "z1500" in args.image:
line_position = 930
elif "z2500" in args.image:
line_position = 885
else:
pcv.fatal_error("Image {0} has an unsupported zoom level.".format(args.image))
# Shape properties relative to user boundary line
device, boundary_header, boundary_data, boundary_img = pcv.analyze_bound_horizontal(img=img, obj=plant_contour,
mask=plant_mask,
line_position=line_position,
device=device,
debug=args.debug,
filename=outfile)
# Determine color properties: Histograms, Color Slices and Pseudocolored Images,
# output color analyzed images
device, color_header, color_data, color_img = pcv.analyze_color(img=img, imgname=args.image, mask=plant_mask,
bins=256,
device=device, debug=args.debug,
hist_plot_type=None,
pseudo_channel="v", pseudo_bkg="img",
resolution=300,
filename=outfile)
# Output shape and color data
result = open(args.result, "a")
result.write('\t'.join(map(str, shape_header)) + "\n")
result.write('\t'.join(map(str, shape_data)) + "\n")
for row in shape_img:
result.write('\t'.join(map(str, row)) + "\n")
result.write('\t'.join(map(str, color_header)) + "\n")
result.write('\t'.join(map(str, color_data)) + "\n")
result.write('\t'.join(map(str, boundary_header)) + "\n")
result.write('\t'.join(map(str, boundary_data)) + "\n")
result.write('\t'.join(map(str, boundary_img)) + "\n")
for row in color_img:
result.write('\t'.join(map(str, row)) + "\n")
result.close()
def main():
args = options()
os.chdir(args.outdir)
# Read RGB image
img, path, filename = pcv.readimage(args.image, mode="native")
# Get metadata from file name
geno_name = filename.split("}{")
geno_name = geno_name[5]
geno_name = geno_name.split("_")
geno_name = geno_name[1]
day = filename.split("}{")
day = day[7]
day = day.split("_")
day = day[1]
day = day.split("}")
day = day[0]
plot = filename.split("}{")
plot = plot[0]
plot = plot.split("_")
plot = plot[1]
exp_name = filename.split("}{")
exp_name = exp_name[1]
exp_name = exp_name.split("_")
exp_name = exp_name[1]
treat_name = filename.split("}{")
treat_name = treat_name[6]
# Create masks using Naive Bayes Classifier and PDFs file
masks = pcv.naive_bayes_classifier(img, args.pdfs)
# The following code will identify the racks in the image, find the top edge, and choose a line along the edge to pick a y coordinate to trim any soil/pot pixels identified as plant material.
# Convert RGB to HSV and extract the Value channel
v = pcv.rgb2gray_hsv(img, 'v')
# Threshold the Value image
v_thresh = pcv.threshold.binary(v, 98, 255, 'light')
# Dilate mask to fill holes
dilate_racks = pcv.dilate(v_thresh, 2, 1)
# Fill in small objects
mask = np.copy(dilate_racks)
fill_racks = pcv.fill(mask, 100000)
#edge detection
edges = cv2.Canny(fill_racks, 60, 180)
#write all the straight lines from edge detection
lines = cv2.HoughLinesP(edges,
rho=1,
theta=1 * np.pi / 180,
threshold=150,
minLineLength=50,
maxLineGap=15)
N = lines.shape[0]
for i in range(N):
x1 = lines[i][0][0]
y1 = lines[i][0][1]
x2 = lines[i][0][2]
y2 = lines[i][0][3]
cv2.line(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
# keep only horizontal lines
N = lines.shape[0]
tokeep = []
for i in range(N):
want = (abs(lines[i][0][1] - lines[i][0][3])) <= 10
tokeep.append(want)
lines = lines[tokeep]
# keep only lines in lower half of image
N = lines.shape[0]
tokeep = []
for i in range(N):
want = 3100 > lines[i][0][1] > 2300
tokeep.append(want)
lines = lines[tokeep]
# assign lines to positions around plants
N = lines.shape[0]
tokeep = []
left = []
mid = []
right = []
for i in range(N):
leftones = lines[i][0][2] <= 2000
left.append(leftones)
midones = 3000 > lines[i][0][2] > 2000
mid.append(midones)
rightones = lines[i][0][0] >= 3300
right.append(rightones)
right = lines[right]
left = lines[left]
mid = lines[mid]
# choose y values for right left mid adding some pixels to go about the pot (subtract because of orientation of axis)
y_left = left[0][0][3] - 50
y_mid = mid[0][0][3] - 50
y_right = right[0][0][3] - 50
# reload original image to write new lines on
img, path, filename = pcv.readimage(args.image)
# write horizontal lines on image
cv2.line(img, (left[0][0][0], left[0][0][1]),
(left[0][0][2], left[0][0][3]), (255, 255, 51), 2)
cv2.line(img, (mid[0][0][0], mid[0][0][1]), (mid[0][0][2], mid[0][0][3]),
(255, 255, 51), 2)
cv2.line(img, (right[0][0][0], right[0][0][1]),
(right[0][0][2], right[0][0][3]), (255, 255, 51), 2)
# Add masks together
added = masks["healthy"] + masks["necrosis"] + masks["stem"]
# Dilate mask to fill holes
dilate_img = pcv.dilate(added, 2, 1)
# Fill in small objects
mask = np.copy(dilate_img)
fill_img = pcv.fill(mask, 400)
ret, inverted = cv2.threshold(fill_img, 75, 255, cv2.THRESH_BINARY_INV)
# Dilate mask to fill holes of plant
dilate_inv = pcv.dilate(inverted, 2, 1)
# Fill in small objects of plant
mask2 = np.copy(dilate_inv)
fill_plant = pcv.fill(mask2, 20)
inverted_img = pcv.invert(fill_plant)
# Identify objects
id_objects, obj_hierarchy = pcv.find_objects(img, inverted_img)
# Define ROIs
roi_left, roi_hierarchy_left = pcv.roi.rectangle(280, 1280, 1275, 1200,
img)
roi_mid, roi_hierarchy_mid = pcv.roi.rectangle(1900, 1280, 1275, 1200, img)
roi_right, roi_hierarchy_right = pcv.roi.rectangle(3600, 1280, 1275, 1200,
img)
# Decide which objects to keep
roi_objects_left, roi_obj_hierarchy_left, kept_mask_left, obj_area_left = pcv.roi_objects(
img, 'partial', roi_left, roi_hierarchy_left, id_objects,
obj_hierarchy)
roi_objects_mid, roi_obj_hierarchy_mid, kept_mask_mid, obj_area_mid = pcv.roi_objects(
img, 'partial', roi_mid, roi_hierarchy_mid, id_objects, obj_hierarchy)
roi_objects_right, roi_obj_hierarchy_right, kept_mask_right, obj_area_right = pcv.roi_objects(
img, 'partial', roi_right, roi_hierarchy_right, id_objects,
obj_hierarchy)
# Combine objects
obj_r, mask_r = pcv.object_composition(img, roi_objects_right,
roi_obj_hierarchy_right)
obj_m, mask_m = pcv.object_composition(img, roi_objects_mid,
roi_obj_hierarchy_mid)
obj_l, mask_l = pcv.object_composition(img, roi_objects_left,
roi_obj_hierarchy_left)
def analyze_bound_horizontal2(img,
obj,
mask,
line_position,
filename=False):
ori_img = np.copy(img)
# Draw line horizontal line through bottom of image, that is adjusted to user input height
if len(np.shape(ori_img)) == 3:
iy, ix, iz = np.shape(ori_img)
else:
iy, ix = np.shape(ori_img)
size = (iy, ix)
size1 = (iy, ix, 3)
background = np.zeros(size, dtype=np.uint8)
wback = np.zeros(size1, dtype=np.uint8)
x_coor = int(ix)
y_coor = int(iy) - int(line_position)
rec_corner = int(iy - 2)
rec_point1 = (1, rec_corner)
rec_point2 = (x_coor - 2, y_coor - 2)
cv2.rectangle(background, rec_point1, rec_point2, (255), 1)
below_contour, below_hierarchy = cv2.findContours(
background, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)[-2:]
below = []
above = []
mask_nonzerox, mask_nonzeroy = np.nonzero(mask)
obj_points = np.vstack((mask_nonzeroy, mask_nonzerox))
obj_points1 = np.transpose(obj_points)
for i, c in enumerate(obj_points1):
xy = tuple(c)
pptest = cv2.pointPolygonTest(below_contour[0],
xy,
measureDist=False)
if pptest == 1:
below.append(xy)
cv2.circle(ori_img, xy, 1, (0, 0, 255))
cv2.circle(wback, xy, 1, (0, 0, 0))
else:
above.append(xy)
cv2.circle(ori_img, xy, 1, (0, 255, 0))
cv2.circle(wback, xy, 1, (255, 255, 255))
return wback
ori_img = np.copy(img)
# Draw line horizontal line through bottom of image, that is adjusted to user input height
if len(np.shape(ori_img)) == 3:
iy, ix, iz = np.shape(ori_img)
else:
iy, ix = np.shape(ori_img)
if obj_r is not None:
wback_r = analyze_bound_horizontal2(img, obj_r, mask_r, iy - y_right)
if obj_m is not None:
wback_m = analyze_bound_horizontal2(img, obj_m, mask_m, iy - y_mid)
if obj_l is not None:
wback_l = analyze_bound_horizontal2(img, obj_l, mask_l, iy - y_left)
threshold_light = pcv.threshold.binary(img, 1, 1, 'dark')
if obj_r is not None:
fgmask_r = pcv.background_subtraction(wback_r, threshold_light)
if obj_m is not None:
fgmask_m = pcv.background_subtraction(wback_m, threshold_light)
if obj_l is not None:
fgmask_l = pcv.background_subtraction(wback_l, threshold_light)
if obj_l is not None:
id_objects_left, obj_hierarchy_left = pcv.find_objects(img, fgmask_l)
if obj_m is not None:
id_objects_mid, obj_hierarchy_mid = pcv.find_objects(img, fgmask_m)
if obj_r is not None:
id_objects_right, obj_hierarchy_right = pcv.find_objects(img, fgmask_r)
# Combine objects
if obj_r is not None:
obj_r2, mask_r2 = pcv.object_composition(img, id_objects_right,
obj_hierarchy_right)
if obj_m is not None:
obj_m2, mask_m2 = pcv.object_composition(img, id_objects_mid,
obj_hierarchy_mid)
if obj_l is not None:
obj_l2, mask_l2 = pcv.object_composition(img, id_objects_left,
obj_hierarchy_left)
# Shape measurements
if obj_l is not None:
shape_header_left, shape_data_left, shape_img_left = pcv.analyze_object(
img, obj_l2, fgmask_l,
geno_name + '_' + plot + '_' + 'A' + '_' + day + '_' + 'shape.jpg')
if obj_r is not None:
shape_header_right, shape_data_right, shape_img_right = pcv.analyze_object(
img, obj_r2, fgmask_r,
geno_name + '_' + plot + '_' + 'C' + '_' + day + '_' + 'shape.jpg')
if obj_m is not None:
shape_header_mid, shape_data_mid, shape_img_mid = pcv.analyze_object(
img, obj_m2, fgmask_m,
geno_name + '_' + plot + '_' + 'B' + '_' + day + '_' + 'shape.jpg')
# Color data
if obj_r is not None:
color_header_right, color_data_right, norm_slice_right = pcv.analyze_color(
img, fgmask_r, 256, None, 'v', 'img',
geno_name + '_' + plot + '_' + 'C' + '_' + day + '_' + 'color.jpg')
if obj_m is not None:
color_header_mid, color_data_mid, norm_slice_mid = pcv.analyze_color(
img, fgmask_m, 256, None, 'v', 'img',
geno_name + '_' + plot + '_' + 'B' + '_' + day + '_' + 'color.jpg')
if obj_l is not None:
color_header_left, color_data_left, norm_slice_left = pcv.analyze_color(
img, fgmask_l, 256, None, 'v', 'img',
geno_name + '_' + plot + '_' + 'A' + '_' + day + '_' + 'color.jpg')
new_header = [
'experiment', 'day', 'genotype', 'treatment', 'plot', 'plant',
'percent.necrosis', 'area', 'hull-area', 'solidity', 'perimeter',
'width', 'height', 'longest_axis', 'center-of-mass-x',
'center-of-mass-y', 'hull_vertices', 'in_bounds', 'ellipse_center_x',
'ellipse_center_y', 'ellipse_major_axis', 'ellipse_minor_axis',
'ellipse_angle', 'ellipse_eccentricity', 'bin-number', 'bin-values',
'blue', 'green', 'red', 'lightness', 'green-magenta', 'blue-yellow',
'hue', 'saturation', 'value'
]
table = []
table.append(new_header)
added2 = masks["healthy"] + masks["stem"]
# Object combine kept objects
if obj_l is not None:
masked_image_healthy_left = pcv.apply_mask(added2, fgmask_l, 'black')
masked_image_necrosis_left = pcv.apply_mask(masks["necrosis"],
fgmask_l, 'black')
added_obj_left = masked_image_healthy_left + masked_image_necrosis_left
sample = "A"
# Calculations
necrosis_left = np.sum(masked_image_necrosis_left)
necrosis_percent_left = float(necrosis_left) / np.sum(added_obj_left)
table.append([
exp_name, day, geno_name, treat_name, plot, sample,
round(necrosis_percent_left, 5), shape_data_left[1],
shape_data_left[2], shape_data_left[3], shape_data_left[4],
shape_data_left[5], shape_data_left[6], shape_data_left[7],
shape_data_left[8], shape_data_left[9], shape_data_left[10],
shape_data_left[11], shape_data_left[12], shape_data_left[13],
shape_data_left[14], shape_data_left[15], shape_data_left[16],
shape_data_left[17], '"{}"'.format(color_data_left[1]),
'"{}"'.format(color_data_left[2]), '"{}"'.format(
color_data_left[3]), '"{}"'.format(color_data_left[4]),
'"{}"'.format(color_data_left[5]), '"{}"'.format(
color_data_left[6]), '"{}"'.format(color_data_left[7]),
'"{}"'.format(color_data_left[8]), '"{}"'.format(
color_data_left[9]), '"{}"'.format(color_data_left[10]),
'"{}"'.format(color_data_left[11])
])
# Object combine kept objects
if obj_m is not None:
masked_image_healthy_mid = pcv.apply_mask(added2, fgmask_m, 'black')
masked_image_necrosis_mid = pcv.apply_mask(masks["necrosis"], fgmask_m,
'black')
added_obj_mid = masked_image_healthy_mid + masked_image_necrosis_mid
sample = "B"
# Calculations
necrosis_mid = np.sum(masked_image_necrosis_mid)
necrosis_percent_mid = float(necrosis_mid) / np.sum(added_obj_mid)
table.append([
exp_name, day, geno_name, treat_name, plot, sample,
round(necrosis_percent_mid,
5), shape_data_mid[1], shape_data_mid[2], shape_data_mid[3],
shape_data_mid[4], shape_data_mid[5], shape_data_mid[6],
shape_data_mid[7], shape_data_mid[8], shape_data_mid[9],
shape_data_mid[10], shape_data_mid[11], shape_data_mid[12],
shape_data_mid[13], shape_data_mid[14], shape_data_mid[15],
shape_data_mid[16], shape_data_mid[17],
'"{}"'.format(color_data_mid[1]), '"{}"'.format(color_data_mid[2]),
'"{}"'.format(color_data_mid[3]), '"{}"'.format(color_data_mid[4]),
'"{}"'.format(color_data_mid[5]), '"{}"'.format(color_data_mid[6]),
'"{}"'.format(color_data_mid[7]), '"{}"'.format(color_data_mid[8]),
'"{}"'.format(color_data_mid[9]), '"{}"'.format(
color_data_mid[10]), '"{}"'.format(color_data_mid[11])
])
# Object combine kept objects
if obj_r is not None:
masked_image_healthy_right = pcv.apply_mask(added2, fgmask_r, 'black')
masked_image_necrosis_right = pcv.apply_mask(masks["necrosis"],
fgmask_r, 'black')
added_obj_right = masked_image_healthy_right + masked_image_necrosis_right
sample = "C"
# Calculations
necrosis_right = np.sum(masked_image_necrosis_right)
necrosis_percent_right = float(necrosis_right) / np.sum(
added_obj_right)
table.append([
exp_name, day, geno_name, treat_name, plot, sample,
round(necrosis_percent_right, 5), shape_data_right[1],
shape_data_right[2], shape_data_right[3], shape_data_right[4],
shape_data_right[5], shape_data_right[6], shape_data_right[7],
shape_data_right[8], shape_data_right[9], shape_data_right[10],
shape_data_right[11], shape_data_right[12], shape_data_right[13],
shape_data_right[14], shape_data_right[15], shape_data_right[16],
shape_data_right[17], '"{}"'.format(color_data_right[1]),
'"{}"'.format(color_data_right[2]), '"{}"'.format(
color_data_right[3]), '"{}"'.format(color_data_right[4]),
'"{}"'.format(color_data_right[5]), '"{}"'.format(
color_data_right[6]), '"{}"'.format(color_data_right[7]),
'"{}"'.format(color_data_right[8]), '"{}"'.format(
color_data_right[9]), '"{}"'.format(color_data_right[10]),
'"{}"'.format(color_data_right[11])
])
if obj_l is not None:
merged2 = cv2.merge([
masked_image_healthy_left,
np.zeros(np.shape(masks["healthy"]), dtype=np.uint8),
masked_image_necrosis_left
]) #blue, green, red
pcv.print_image(
merged2, geno_name + '_' + plot + '_' + 'A' + '_' + day + '_' +
'merged.jpg')
if obj_m is not None:
merged3 = cv2.merge([
masked_image_healthy_mid,
np.zeros(np.shape(masks["healthy"]), dtype=np.uint8),
masked_image_necrosis_mid
]) #blue, green, red
pcv.print_image(
merged3, geno_name + '_' + plot + '_' + 'B' + '_' + day + '_' +
'merged.jpg')
if obj_r is not None:
merged4 = cv2.merge([
masked_image_healthy_right,
np.zeros(np.shape(masks["healthy"]), dtype=np.uint8),
masked_image_necrosis_right
]) #blue, green, red
pcv.print_image(
merged4, geno_name + '_' + plot + '_' + 'C' + '_' + day + '_' +
'merged.jpg')
# Save area results to file (individual csv files for one image...)
file_name = filename.split("}{")
file_name = file_name[0] + "}{" + file_name[5] + "}{" + file_name[7]
outfile = str(file_name[:-4]) + 'csv'
with open(outfile, 'w') as f:
for row in table:
f.write(','.join(map(str, row)) + '\n')
print(filename)
def main():
# Get options
args = options()
debug = args.debug
# Read image
img, path, filename = pcv.readimage(args.image)
# Pipeline step
device = 0
device, img1 = pcv.white_balance(device, img, debug,
(100, 100, 1000, 1000))
img = img1
#seedmask, path1, filename1 = pcv.readimage(args.mask)
#device, seedmask = pcv.rgb2gray(seedmask, device, debug)
#device, inverted = pcv.invert(seedmask, device, debug)
#device, masked_img = pcv.apply_mask(img, inverted, 'white', device, debug)
device, img_gray_sat = pcv.rgb2gray_hsv(img1, 's', device, debug)
device, img_binary = pcv.binary_threshold(img_gray_sat, 70, 255, 'light',
device, debug)
img_binary1 = np.copy(img_binary)
device, fill_image = pcv.fill(img_binary1, img_binary, 300, device, debug)
device, seed_objects, seed_hierarchy = pcv.find_objects(
img, fill_image, device, debug)
device, roi1, roi_hierarchy1 = pcv.define_roi(img, 'rectangle', device,
None, 'default', debug, True,
1500, 1000, -1000, -500)
device, roi_objects, roi_obj_hierarchy, kept_mask, obj_area = pcv.roi_objects(
img, 'partial', roi1, roi_hierarchy1, seed_objects, seed_hierarchy,
device, debug)
img_copy = np.copy(img)
for i in range(0, len(roi_objects)):
rand_color = pcv.color_palette(1)
cv2.drawContours(img_copy,
roi_objects,
i,
rand_color[0],
-1,
lineType=8,
hierarchy=roi_obj_hierarchy)
pcv.print_image(
img_copy,
os.path.join(args.outdir, filename[:-4]) + "-seed-confetti.jpg")
shape_header = [] # Store the table header
table = [] # Store the PlantCV measurements for each seed in a table
for i in range(0, len(roi_objects)):
if roi_obj_hierarchy[0][i][
3] == -1: # Only continue if the object is an outermost contour
# Object combine kept objects
# Inputs:
# contours = object list
# device = device number. Used to count steps in the pipeline
# debug = None, print, or plot. Print = save to file, Plot = print to screen.
device, obj, mask = pcv.object_composition(
img, [roi_objects[i]], np.array([[roi_obj_hierarchy[0][i]]]),
device, None)
if obj is not None:
# Measure the area and other shape properties of each seed
# Inputs:
# img = image object (most likely the original), color(RGB)
# imgname = name of image
# obj = single or grouped contour object
# device = device number. Used to count steps in the pipeline
# debug = None, print, or plot. Print = save to file, Plot = print to screen.
# filename = False or image name. If defined print image
device, shape_header, shape_data, shape_img = pcv.analyze_object(
img, "img", obj, mask, device, None)
if shape_data is not None:
table.append(shape_data[1])
data_array = np.array(table)
maxval = np.argmax(data_array)
maxseed = np.copy(img)
cv2.drawContours(maxseed, roi_objects, maxval, (0, 255, 0), 10)
imgtext = "This image has " + str(len(data_array)) + " seeds"
sizeseed = "The largest seed is in green and is " + str(
data_array[maxval]) + " pixels"
cv2.putText(maxseed, imgtext, (500, 300), cv2.FONT_HERSHEY_SIMPLEX, 5,
(0, 0, 0), 10)
cv2.putText(maxseed, sizeseed, (500, 600), cv2.FONT_HERSHEY_SIMPLEX, 5,
(0, 0, 0), 10)
pcv.print_image(maxseed,
os.path.join(args.outdir, filename[:-4]) + "-maxseed.jpg")
