Upload 2 files

Image_height.py

@@ -0,0 +1,74 @@
+from plantcv import plantcv as pcv 
+from PIL import Image
+import glob
+import matplotlib.pyplot as plt
+import os
+import numpy as np
+import pandas as pd
+from sklearn.decomposition import PCA
+from skimage.filters import threshold_li
+
+
+class options:
+    def __init__(self, image_path):
+        self.image = image_path
+        self.debug = "plot"
+        self.tmp_dir = "plantpattern"
+        self.result = os.path.join(self.tmp_dir, "try2.txt")
+        self.writeimg = False 
+        self.outdir = "plantpattern"
+        os.makedirs(self.tmp_dir, exist_ok=True)
+
+def image_height(image_path, camera_distance):
+    # Get options
+    args = options(image_path)
+
+    # Set debug to the global parameter 
+    pcv.params.debug = args.debug
+
+    # Read image
+
+    # Inputs:
+    #   filename - Image file to be read in 
+    #   mode - How to read in the image; either 'native' (default), 'rgb', 'gray', or 'csv'
+    original_img, path, filename = pcv.readimage(filename=args.image)
+
+    gray = pcv.rgb2gray(rgb_img=original_img)
+    thresh = threshold_li(gray)
+    binary = gray > thresh
+
+    s_thresh = binary.astype(int)
+    bs = pcv.logical_or(bin_img1=gray, bin_img2=np.uint8(s_thresh*255))
+    masked = pcv.apply_mask(img=original_img, mask=bs, mask_color='black')
+    ab_fill = pcv.fill(bin_img=s_thresh, size=10)
+    masked2 = pcv.apply_mask(img=masked, mask=ab_fill, mask_color='black')
+    id_objects, obj_hierarchy = pcv.find_objects(img=np.uint8(original_img*255), mask=ab_fill)
+    roi1, roi_hierarchy= pcv.roi.rectangle(img=masked2, x=95, y=5, h=500, w=350)
+    roi_objects, hierarchy3, kept_mask, obj_area = pcv.roi_objects(img=original_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=original_img, contours=roi_objects, hierarchy=hierarchy3)
+    analysis_image = pcv.analyze_object(img=original_img, obj=obj, mask=mask, label="default")
+    boundary_image2 = pcv.analyze_bound_horizontal(img=np.uint8(original_img*255), obj=obj, mask=mask, 
+                                                line_position=510, label="default")
+    height_above_reference = pcv.outputs.observations['default']['height_above_reference']['value']
+    #small greenhouse distance = 30cm
+    #56.3 * 56.3
+    image_width, image_height, h = original_img.shape
+    x_offset = 56.3/512
+    actual_greenhouse_height = x_offset * height_above_reference
+    # print("Actual Height of plant:", actual_greenhouse_height)
+    # Create a DataFrame with the actual height
+    data = {'Parameter': ['Height Above Reference (pixels)', 'Plant height (cm)', 'Image Width (pixels)', 'Pixel Size (cm)'],
+            'Value': [height_above_reference, actual_greenhouse_height, image_width, x_offset]}
+    df = pd.DataFrame(data)
+
+    return df, actual_greenhouse_height
+
+
+
+
+

Image_stitching.py

@@ -0,0 +1,94 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import pdb
+
+def rotate_to_horizontal(image):
+    # Rotate the image to horizontal (90 degrees counterclockwise)
+    rotated_image = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    return rotated_image
+
+def rotate_to_vertical(image):
+    # Rotate the image back to vertical (90 degrees clockwise)
+    rotated_image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+    return rotated_image
+
+def plot_images(images):
+    num_images = len(images)
+    
+    for i, image in enumerate(images):
+        plt.figure(figsize=(6, 6))
+        plt.imshow(image)
+        plt.title(f"Image {i+1}/{num_images}")
+        plt.axis('off')
+        plt.show()
+
+def image_stitching(images):
+    # images = [cv2.imread(path) for path in image_paths]
+
+    images = [image.astype(np.uint8) for image in images]
+    images = [rotate_to_horizontal(image) for image in images]
+    images = list(reversed(images))
+    if len(images) == 15:
+        images = images[2:12]
+    #plot_images(images)
+    
+    # Create a list to store the stitched images
+    stitched_images = []
+
+    # Accumulated homography matrix for stitching
+    accumulated_homography = np.eye(3)
+
+    # Iterate through pairs of adjacent images and stitch them together
+    for i in range(len(images) - 1):
+        # Perform keypoint and feature descriptor extraction
+        orb = cv2.ORB_create()
+        keypoints_and_descriptors = [orb.detectAndCompute(image, None) for image in [images[i], images[i + 1]]]
+
+        # Match the keypoints using Brute-Force Matcher
+        bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
+        matches = bf.match(keypoints_and_descriptors[0][1], keypoints_and_descriptors[1][1])
+
+        # Filter the matches to remove outliers using RANSAC
+        src_pts = np.float32([keypoints_and_descriptors[0][0][m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
+        dst_pts = np.float32([keypoints_and_descriptors[1][0][m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
+
+        M, _ = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
+
+        # Accumulate the homography matrices
+        accumulated_homography = np.dot(M, accumulated_homography)
+
+        # Warp perspective and stitch the images
+        stitched_image = cv2.warpPerspective(images[i + 1], accumulated_homography, 
+                                             (images[i].shape[1] + images[i + 1].shape[1], images[i].shape[0]))
+        stitched_image[0:images[i].shape[0], 0:images[i].shape[1]] = images[i]
+
+        # Remove the empty pixels and retain maximum image information
+        # stitched_image = remove_empty_pixels(stitched_image)
+
+        stitched_images.append(stitched_image)
+
+    # Combine all stitched images into a final panorama
+    final_panorama = stitched_images[0]
+    for i in range(1, len(stitched_images)):
+        final_panorama = cv2.warpPerspective(stitched_images[i], np.eye(3), 
+                                             (final_panorama.shape[1] + stitched_images[i].shape[1], final_panorama.shape[0]))
+        final_panorama[0:stitched_images[i].shape[0], 0:stitched_images[i].shape[1]] = stitched_images[i]
+
+    gray_images = [cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) for image in images[:2]]
+
+    # Draw the keypoints on the images
+    keypoints_drawn = [cv2.drawKeypoints(gray_image, kp[0], None, color=(0, 255, 0), 
+                                         flags=cv2.DrawMatchesFlags_DRAW_RICH_KEYPOINTS) for gray_image, kp in 
+                                         zip(gray_images, keypoints_and_descriptors[:2])]
+
+    # Draw the matches on the images
+    matches_drawn = cv2.drawMatches(images[0], keypoints_and_descriptors[0][0], images[1], 
+                                    keypoints_and_descriptors[1][0], matches, None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
+    
+    # Crop the final image to 512x512 centered around the middle
+    cropped_final_panorama = final_panorama[:512, :512]
+    rotated_final_panorama = rotate_to_vertical(cropped_final_panorama)
+
+
+    return rotated_final_panorama