Update app.py

app.py

@@ -1,130 +1,122 @@
 import streamlit as st
 import degirum as dg
-from PIL import Image
 import degirum_tools
+from PIL import Image
 
-# -----------------------------
-# Page config
-# -----------------------------
 st.set_page_config(
-    page_title="DeGirum License Plate Demo",
-    page_icon="🚗",
-    layout="centered",
+    page_title="Paddle OCR with DeGirum",
+    page_icon="📝",
 )
 
-# -----------------------------
-# App title & intro
-# -----------------------------
-st.title("License Plate Detection & Recognition (DeGirum Cloud)")
-
-st.markdown(
-    """
-This demo shows how to build a simple **Automatic License Plate Recognition (ALPR)** 
-pipeline using models hosted on **DeGirum Cloud**.
-
-**What this app does:**
-1. Detects license plates in an uploaded image.
-2. Crops each plate region.
-3. Runs an OCR model to read the characters on the plate.
-4. Displays the original and annotated images **side by side**.
-"""
+st.title("Paddle OCR Text Detection and Recognition")
+st.write(
+    "Upload an image containing text and click **Run OCR** to detect text regions "
+    "and recognize the text using PaddleOCR models on DeGirum / Hailo."
 )
 
-st.sidebar.header("About this demo")
-st.sidebar.markdown(
-    """
-- **Inference location:** DeGirum Cloud  
-- **Models used:**
-  - LP detection: `yolov8n_relu6_global_lp_det--640x640_quant_n2x_orca1_1`
-  - LP OCR: `yolov8s_relu6_lp_ocr_7ch--256x128_quant_n2x_orca1_1`
-- **Libraries:**
-  - `degirum`
-  - `degirum_tools`
-  - `streamlit`
-"""
-)
 
-# -----------------------------
-# Configuration
-# -----------------------------
-hw_location = "@cloud"
-model_zoo_url = "https://cs.degirum.com/degirum/degirum"
-
-lp_det_model_name = "yolov8n_relu6_global_lp_det--640x640_quant_n2x_orca1_1"
-lp_ocr_model_name = "yolov8s_relu6_lp_ocr_7ch--256x128_quant_n2x_orca1_1"
-
-
-# -----------------------------
-# Model loading (cached)
-# -----------------------------
-@st.cache_resource(show_spinner=True)
-def load_compound_model():
-    model_zoo = dg.connect(hw_location, model_zoo_url, token=st.secrets["DG_TOKEN"])
-
-    lp_det_model = model_zoo.load_model(
-        lp_det_model_name,
+@st.cache_resource
+def load_crop_model():
+    """
+    Load Paddle OCR detection + recognition models and wrap them in
+    a CroppingAndClassifyingCompoundModel so detection crops feed into OCR.
+    """
+    # Read connection info from Streamlit secrets
+    inference_host = st.secrets.get("DG_INFERENCE_HOST", "@local")
+    zoo_url = st.secrets.get("DG_ZOO_URL", "degirum/hailo")
+    device_type = st.secrets.get("DG_DEVICE_TYPE", "HAILORT/HAILO8")
+    token = st.secrets.get("DG_TOKEN", "")
+
+    # Ensure device_type is a list (as required by dg.load_model)
+    if isinstance(device_type, str):
+        device_type_list = [device_type]
+    else:
+        device_type_list = device_type
+
+    # Model names (same as in your notebook)
+    paddle_ocr_det_model_name = "paddle_ocr_detection--544x960_quant_hailort_hailo8_1"
+    paddle_ocr_rec_model_name = "paddle_ocr_recognition--48x320_quant_hailort_hailo8_1"
+
+    # Load detection model
+    text_det_model = dg.load_model(
+        model_name=paddle_ocr_det_model_name,
+        inference_host_address=inference_host,
+        zoo_url=zoo_url,
+        device_type=device_type_list,
+        token=token,
         image_backend="pil",
-        overlay_color=(255, 0, 0),
-        overlay_line_width=2,
-        overlay_font_scale=2,
     )
 
-    lp_ocr_model = model_zoo.load_model(
-        lp_ocr_model_name,
+    # Load recognition model
+    text_rec_model = dg.load_model(
+        model_name=paddle_ocr_rec_model_name,
+        inference_host_address=inference_host,
+        zoo_url=zoo_url,
+        device_type=device_type_list,
+        token=token,
         image_backend="pil",
     )
 
-    # Create a compound cropping model with 5% crop extent
+    # Create compound cropping + classification model
     crop_model = degirum_tools.CroppingAndClassifyingCompoundModel(
-        lp_det_model, lp_ocr_model, 5.0
+        text_det_model,
+        text_rec_model,
     )
 
     return crop_model
 
 
-crop_model = load_compound_model()
-
-# -----------------------------
-# File upload UI
-# -----------------------------
-st.subheader("Upload an image and run the models")
-
-uploaded_file = st.file_uploader(
-    "Choose an image containing a vehicle / license plate",
-    type=["jpg", "jpeg", "png"],
-)
-
-run_button = st.button("Run Inference", type="primary", disabled=uploaded_file is None)
-
-# -----------------------------
-# Inference
-# -----------------------------
-if run_button and uploaded_file is not None:
-    with st.spinner("Running license plate detection and recognition..."):
-        # Load full-res image and create a display copy
-        orig_image = Image.open(uploaded_file).convert("RGB")
-        display_image = orig_image.copy()
-        display_image.thumbnail((640, 640), Image.Resampling.LANCZOS)
+crop_model = load_crop_model()
 
-        # Run model on the resized display image
-        inference_results = crop_model(display_image)
+st.text("Upload an image. Then click on the Run OCR button.")
 
-    st.subheader("Results")
-
-    col1, col2 = st.columns(2, gap="medium")
-
-    with col1:
-        st.markdown("**Original image**")
-        st.image(display_image, use_container_width=True)
-
-    with col2:
-        st.markdown("**Detection & recognition**")
-        st.image(
-            inference_results.image_overlay,
-            caption="License plates with bounding boxes and labels",
-            use_container_width=True,
-        )
-
-    st.caption("Inference complete. Detected plates and OCR results are shown on the right.")
-elif uploaded_file is None:
-    st.info("👈 Upload an image to get started.")
+with st.form("ocr_form"):
+    uploaded_file = st.file_uploader(
+        "Input image",
+        type=["jpg", "jpeg", "png", "bmp", "tiff"],
+    )
+    submitted = st.form_submit_button("Run OCR")
+
+    if submitted:
+        if uploaded_file is None:
+            st.warning("Please upload an image first.")
+        else:
+            # Load and optionally resize the image
+            image = Image.open(uploaded_file).convert("RGB")
+            # You can limit size if you want
+            # image.thumbnail((960, 960), Image.Resampling.LANCZOS)
+
+            # Run inference
+            inference_result = crop_model(image)
+
+            # Show image with detected text boxes
+            st.image(
+                inference_result.image_overlay,
+                caption="Image with detected text regions",
+                use_column_width=True,
+            )
+
+            # Try to show OCR results in a table
+            st.subheader("OCR Results")
+            try:
+                df = inference_result.to_pandas()
+                st.dataframe(df)
+
+                # If there is a column with recognized text, try to display it nicely
+                text_cols = [
+                    col
+                    for col in df.columns
+                    if "text" in col.lower() or "label" in col.lower()
+                ]
+                if text_cols:
+                    st.subheader("Recognized Text")
+                    all_texts = []
+                    for col in text_cols:
+                        all_texts.extend(
+                            [str(x) for x in df[col].dropna().tolist()]
+                        )
+                    if all_texts:
+                        st.write("\n".join(f"- {t}" for t in all_texts))
+            except Exception:
+                st.write("Raw result object:")
+                st.write(inference_result)