Display updates to app file

app.py

@@ -51,7 +51,7 @@ import tensorflow_hub as hub
 
 
 @st.cache_resource
-def load_models_etc():
+def load_models():
     #OpenAI elements
     #secrets = toml.load(".vscode/streamlit/secrets.toml")
     #client_d = OpenAI(api_key = secrets["OPENAI_API_KEY"])
@@ -94,7 +94,8 @@ def load_models_etc():
     return client_d,detector_d,Dis_percentage_d,Details_d,cnn_model_d,xception_model_d,mobilenet_model_d,class_labels_d
 
 
-client,detector,Dis_percentage,Details,cnn_model,xception_model,mobilenet_model,class_labels  = load_models_etc()
+# Loading the models. load_models() methos is cached and will be loaded only once during the initial boot.
+client,detector,Dis_percentage,Details,cnn_model,xception_model,mobilenet_model,class_labels  = load_models()
 
 
 # Identify extent of spot or lesion coverage on leaf
@@ -126,7 +127,7 @@ def identify_spots_or_lesions(img):
     contoured_image = cv2.drawContours(cv_image.copy(), filtered_contours, -1, (0, 255, 0), 1)
 
     # Visualization
-    plt.figure(figsize=(25, 8))
+    mfig = plt.figure(figsize=(25, 8))
     plt.subplot(1, 5, 1)
     plt.imshow(cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB))
     plt.title('Original Image')
@@ -146,7 +147,9 @@ def identify_spots_or_lesions(img):
     plt.subplot(1, 5, 5)
     plt.imshow(cv2.cvtColor(contoured_image, cv2.COLOR_BGR2RGB))
     plt.title('Spots or Lesions Identified')
-    plt.show()
+    #plt.show()
+    st.pyplot(mfig)
+
     return(percentage_spots)
 
 
@@ -216,12 +219,6 @@ def classify_image(image):
     # preprocess_input from Xception to scale the image to -1 to +1
     #img_array = preprocess_input(img_array)
 
-    # Perform inference using the TensorFlow Lite model
-    #interpreter.set_tensor(interpreter.get_input_details()[0]['index'], img_array)
-    #interpreter.invoke()
-    #prediction = interpreter.get_tensor(interpreter.get_output_details()[0]['index'])
-
-
     mobilenet_input = mobilenet_preprocess(np.copy(img_batch))
     xception_input = xception_preprocess(np.copy(img_batch))
     cnn_input = img_batch / 255.0  # normalization for generic CNN model
@@ -231,7 +228,6 @@ def classify_image(image):
     xception_preds = xception_model(xception_input, training = False)
     cnn_preds = cnn_model(cnn_input, training = False)
 
-
     # Get the most likely class index from predictions
     mobilenet_class = np.argmax(mobilenet_preds, axis=1)
     xception_class = np.argmax(xception_preds, axis=1)
@@ -250,14 +246,10 @@ def classify_image(image):
     second_class_prob = averaged_probs_np[np.arange(top_class_index.size), second_class_index]
     predicted_class_name = class_labels[top_class_index[0]]
     second_class_name = class_labels[second_class_index[0]]
-
     # --------------------------------
 
-    if top_class_prob[0] < 0.999:  # threshold close to 1 to handle floating-point precision issues
-        st.write("Second predicted class:", second_class_name)
-        st.write(f"Second class confidence: {second_class_prob[0]:.3%}")
-    else:
-        st.write("Second predicted class: None")
+    st.write("Image class:", predicted_class_name)
+    st.write(f"Confidence: {top_class_prob[0]:.2%}")
 
     if "healthy" in predicted_class_name:
         st.write(f"{predicted_class_name} is healthy, skipping further analysis.")
@@ -269,7 +261,6 @@ def classify_image(image):
         else:
             spots_percentage = identify_spots_or_lesions(image)
     
-    
     if predicted_class_name in Dis_percentage['Plant'].values:
             row = Dis_percentage.loc[Dis_percentage['Plant'] == predicted_class_name].iloc[0]
             severity_disease = plot_dis_percentage(row, spots_percentage)
@@ -283,15 +274,96 @@ def classify_image(image):
             return severity_disease, top_class_prob[0], second_class_name
     else:
         st.write("No data available for this plant disease in DataFrame.")
-        return
 
+    if top_class_prob[0] < 0.999:  # threshold close to 1 to handle floating-point precision issues
+        st.write("Second predicted class:", second_class_name)
+        st.write(f"Second class confidence: {second_class_prob[0]:.3%}")
+    else:
+        st.write("Second predicted class: None")
+    
+    return
+
+
+def display_image(image):
+    fig = plt.figure(figsize=(12, 6))
+    plt.grid(False)
+    plt.imshow(image)
+    plt.show()
 
 
 
+def draw_bounding_box_on_image(image, ymin, xmin, ymax, xmax, color, font, thickness=4, display_str_list=()):
+  """Adds a bounding box to an image."""
+  draw = ImageDraw.Draw(image)
+  im_width, im_height = image.size
+  (left, right, top, bottom) = (xmin * im_width, xmax * im_width, ymin * im_height, ymax * im_height)
+  draw.line([(left, top), (left, bottom), (right, bottom), (right, top), (left, top)], width=thickness, fill=color)
+
+  # height of the display strings added to the top of the bounding
+  # box exceeds the top of the image - stack below:
+  display_str_heights = [font.getbbox(ds)[3] for ds in display_str_list]
+  total_display_str_height = (1 + 2 * 0.05) * sum(display_str_heights)
+
+  if top > total_display_str_height:
+    text_bottom = top
+  else:
+    text_bottom = top + total_display_str_height
+  # Reverse list and print from bottom to top.
+  for display_str in display_str_list[::-1]:
+    bbox = font.getbbox(display_str)
+    text_width, text_height = bbox[2], bbox[3]
+    margin = np.ceil(0.05 * text_height)
+    draw.rectangle([(left, text_bottom - text_height - 2 * margin),  (left + text_width, text_bottom)], fill=color)
+    draw.text((left + margin, text_bottom - text_height - margin), display_str, fill="black", font=font)
+    text_bottom -= text_height - 2 * margin
+
+
+
+def draw_boxes(image, boxes, class_names, scores, max_boxes=3, min_score=0.1):
+  #"""Overlay labeled boxes on an image with formatted scores and label names."""
+  colors = list(ImageColor.colormap.values())
+
+  font = ImageFont.load_default()
+
+  # Prepare a list of all detections that meet the score threshold
+  filtered_boxes = [(boxes[i], scores[i], class_names[i]) for i in range(len(scores)) if scores[i] >= min_score]
+
+  # Sort detections based on scores in descending order
+  filtered_boxes.sort(key=lambda x: x[1], reverse=False)
+
+  # Process each box to draw (limited by max_boxes)
+  for i, (box, score, class_name) in enumerate(filtered_boxes[:max_boxes]):
+    ymin, xmin, ymax, xmax = tuple(box)
+    display_str = "{}: {:.2f}%".format(class_name.decode("ascii"), score * 100)
+    color = colors[hash(class_name) % len(colors)]
+    draw_bounding_box_on_image( image, ymin, xmin, ymax, xmax, color, font, display_str_list=[display_str])
+
+  # Convert PIL Image back to numpy array for display (if necessary)
+  return np.array(image) if isinstance(image, Image.Image) else image
+
+
+
+
+# ----------------------------------------------------------------------------------------------------//
 # Streamlit app
 
-tab1, tab2, tab3 = st.tabs(["Home", "Solution", "Team"])
 
+def openai_remedy(searchval):
+        completion = client.chat.completions.create(
+                            model="gpt-4-turbo",
+                            messages=[
+                            {"role": "user", "content": "List out the most relevant remediation steps for " + searchval + " in 7 bullet points"}  
+                            ],
+                            temperature=0.1,
+                            max_tokens=2000,
+                            top_p=0.1
+                        )
+        st.markdown(completion.choices[0].message.content)
+        #st.markdown(completion.choices[0].delta.content)
+        return
+
+
+tab1, tab2, tab3 = st.tabs(["Home", "Solution", "Team"])
 
 
 #First Tab: Title of Application and description
@@ -315,20 +387,17 @@ Early detection of plant diseases is paramount for farmers to protect their crop
 
 
 
-
 #Second Tab: Image upload and disease detection and remidy susgestions
 with tab2: 
     st.title("Plant classification, Disease detection and management")
-
     # Load and display the image
     uploaded_file = st.file_uploader("Upload Leaf Image...", type=["jpg", "jpeg", "png"], key="uploader")
 
-
     if uploaded_file is not None:
-    
         print("Image successfully uploaded!")
         # Read the uploaded image file
-        st.image(uploaded_file, caption='Uploaded Image', use_column_width=True)
+        #st.image(uploaded_file, caption='Uploaded Image', use_column_width=True,width=100)
+        st.image(uploaded_file, caption='Uploaded Image', width=300)
         image = Image.open(uploaded_file)
 
         image_for_drawing = image.copy()
@@ -344,22 +413,24 @@ with tab2:
         result = {key: value.numpy() for key, value in result.items()}
 
         #st.write("Found %d objects." % len(result["detection_scores"]))
-        st.write("Inference time: ", end_time - start_time)
+        #st.write("Inference time: ", end_time - start_time)
 
         detection_scores = result["detection_scores"]
         detection_class_entities = result["detection_class_entities"]
 
-        #image_with_boxes = draw_boxes(image_for_drawing, result["detection_boxes"],detection_class_entities, detection_scores)
-
+        # Class Detections displays
+        image_with_boxes = draw_boxes(image_for_drawing, result["detection_boxes"],detection_class_entities, detection_scores)
         #display_image(image_with_boxes)
+        st.image(image_with_boxes, caption='Uploaded Image', width=300)
 
         top_3_idx = np.argsort(-detection_scores)[:3]
 
         for idx in top_3_idx:
             entity = detection_class_entities[idx].decode('utf-8')
+
             if "Plant" == entity:
                 plant_score = detection_scores[idx]
-                st.write(f"Plant probability score: {plant_score:.2%}")
+                st.write(f"Plant Probability score using Faster R-CNN Inception Resnet V2 Object detection model :  {plant_score:.2%}")
                 result1 = classify_image(image)
 
                 if result1 is not None:
@@ -367,22 +438,12 @@ with tab2:
                     new1 = result1[0] + ""
                     newresult = new1.replace("_"," ")
                     newresult2 = newresult.replace("-"," ")
-                    st.markdown("Searching disease management steps for " + ":red[" + newresult2 + "]... :eyes:")
-                    completion = client.chat.completions.create(
-                            model="gpt-4-turbo",
-                            messages=[
-                            {"role": "user", "content": "List out the most relevant remediation steps for " + newresult2 + " in 7 bullet points"}  
-                            ],
-                            temperature=0.1,
-                            max_tokens=2000,
-                            top_p=0.1
-                        )
-                    st.markdown(completion.choices[0].message.content)
-                    #st.markdown(completion.choices[0].delta.content)
+                    st.markdown("Fetching disease management steps for " + ":red[" + newresult2 + "]... :eyes:")
+                    openai_remedy(newresult2)
+                    
     else:
         print("No file uploaded.")
     
-    
     # Disclaimer
     st.write("""
 ### Disclaimer
@@ -394,9 +455,6 @@ While our disease identification system strives for accuracy and reliability, it
 
 
 
-
-
-
 # Third Tab
 with tab3:
     st.title("CDS Batch 6 - Group 2:")
@@ -428,92 +486,3 @@ with tab3:
 
     st.write("Shashank Srivastava")
     st.divider()      
-
-
-
-
-
-def display_image(image):
-    fig = plt.figure(figsize=(12, 6))
-    plt.grid(False)
-    plt.imshow(image)
-    plt.show()
-
-
-def draw_bounding_box_on_image(image,
-                               ymin,
-                               xmin,
-                               ymax,
-                               xmax,
-                               color,
-                               font,
-                               thickness=4,
-                               display_str_list=()):
-  """Adds a bounding box to an image."""
-  draw = ImageDraw.Draw(image)
-  im_width, im_height = image.size
-  (left, right, top, bottom) = (xmin * im_width, xmax * im_width,
-                                ymin * im_height, ymax * im_height)
-  draw.line([(left, top), (left, bottom), (right, bottom), (right, top),
-             (left, top)],
-            width=thickness,
-            fill=color)
-
-  # height of the display strings added to the top of the bounding
-  # box exceeds the top of the image - stack below:
-  display_str_heights = [font.getbbox(ds)[3] for ds in display_str_list]
-  total_display_str_height = (1 + 2 * 0.05) * sum(display_str_heights)
-
-  if top > total_display_str_height:
-    text_bottom = top
-  else:
-    text_bottom = top + total_display_str_height
-  # Reverse list and print from bottom to top.
-  for display_str in display_str_list[::-1]:
-    bbox = font.getbbox(display_str)
-    text_width, text_height = bbox[2], bbox[3]
-    margin = np.ceil(0.05 * text_height)
-    draw.rectangle([(left, text_bottom - text_height - 2 * margin),
-                    (left + text_width, text_bottom)],
-                   fill=color)
-    draw.text((left + margin, text_bottom - text_height - margin),
-              display_str,
-              fill="black",
-              font=font)
-    text_bottom -= text_height - 2 * margin
-
-
-
-def draw_boxes(image, boxes, class_names, scores, max_boxes=3, min_score=0.1):
-  """Overlay labeled boxes on an image with formatted scores and label names."""
-  colors = list(ImageColor.colormap.values())
-
-  try:
-    font = ImageFont.truetype("/usr/share/fonts/truetype/liberation/LiberationSansNarrow-Regular.ttf", 15)
-  except IOError:
-    print("Font not found, using default font.")
-    font = ImageFont.load_default()
-
-  # Prepare a list of all detections that meet the score threshold
-  filtered_boxes = [(boxes[i], scores[i], class_names[i]) for i in range(len(scores)) if scores[i] >= min_score]
-
-  # Sort detections based on scores in descending order
-  filtered_boxes.sort(key=lambda x: x[1], reverse=False)
-
-  # Process each box to draw (limited by max_boxes)
-  for i, (box, score, class_name) in enumerate(filtered_boxes[:max_boxes]):
-    ymin, xmin, ymax, xmax = tuple(box)
-    display_str = "{}: {:.2f}%".format(class_name.decode("ascii"), score * 100)
-    color = colors[hash(class_name) % len(colors)]
-    draw_bounding_box_on_image(
-        image,
-        ymin,
-        xmin,
-        ymax,
-        xmax,
-        color,
-        font,
-        display_str_list=[display_str])
-
-  # Convert PIL Image back to numpy array for display (if necessary)
-  return np.array(image) if isinstance(image, Image.Image) else image