Add NemaQuant Flask application files

Dockerfile

@@ -0,0 +1,31 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+# --no-cache-dir: Disables the cache to reduce image size.
+# -r requirements.txt: Specifies the file containing the list of packages to install.
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container at /app
+# This includes app.py, nemaquant.py, templates/, static/, etc.
+COPY . .
+
+# Make port 7860 available to the world outside this container
+# This is the port Flask will run on (as configured in app.py)
+# Hugging Face Spaces typically uses this port
+EXPOSE 7860
+
+# Define environment variables (optional, can be useful)
+# ENV NAME=World
+
+# Run app.py when the container launches
+# Use gunicorn for production deployment if preferred over Flask's development server
+# CMD ["gunicorn", "--bind", "0.0.0.0:7860", "app:app"]
+# For simplicity during development and typical HF Spaces use:
+CMD ["python", "app.py"] 

README.md

@@ -8,3 +8,83 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# NemaQuant Flask App for Hugging Face Spaces
+
+This repository contains a Flask application designed to provide a web interface for the `nemaquant.py` script, allowing users to upload images and run nematode egg detection via a Hugging Face Space.
+
+## Project Structure
+
+```
+/
+├── app.py                  # Main Flask application logic
+├── nemaquant.py            # Original image analysis script
+├── requirements.txt        # Python dependencies
+├── Dockerfile              # Docker configuration for HF Spaces
+├── README.md               # This file
+├── templates/
+│   └── index.html          # HTML template for the frontend
+├── static/
+│   ├── style.css           # CSS styles
+│   └── script.js           # JavaScript for frontend interactions
+├── uploads/                # Directory for user-uploaded files (created automatically)
+├── results/                # Directory for output files (created automatically)
+└── weights.pt              # YOLO model weights (Ensure this is present or downloaded)
+```
+
+## Hugging Face Space Setup
+
+1.  **Create a new Space:** Go to [huggingface.co/new-space](https://huggingface.co/new-space).
+2.  **Owner & Space Name:** Choose your username/organization and a name for the space (e.g., `nemaquant-demo`).
+3.  **License:** Select an appropriate license (e.g., Apache 2.0).
+4.  **SDK:** Select **Docker**. Choose the **Blank** template.
+5.  **Hardware:** Select appropriate hardware (e.g., CPU Basic should be sufficient initially, but might need upgrading depending on model size and processing time).
+6.  **Secrets (Optional):** If your application needs API keys or other secrets, add them here.
+7.  **Create Space.**
+
+8.  **Upload Files:** Upload all the files from this repository to your new Hugging Face Space repository. You can do this via the web interface or using Git:
+    ```bash
+    # Clone your new space repository
+    git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+    cd YOUR_SPACE_NAME
+
+    # Add all your project files (ensure you have weights.pt)
+    # ... copy files here ...
+
+    # Commit and push
+    git add .
+    git commit -m "Initial commit of NemaQuant app"
+    git push
+    ```
+
+9.  **Model Weights (`weights.pt`):**
+    *   Make sure the `weights.pt` file required by `nemaquant.py` is included in the root directory of your repository.
+    *   If the weights file is large, consider using Git LFS (Large File Storage). Enable LFS in your Space settings under the "Settings" tab.
+        ```bash
+        # Install git-lfs if you haven't already
+        git lfs install
+        git lfs track "*.pt" # Track the weights file
+        git add .gitattributes # Add the tracking file
+        git add weights.pt
+        git commit -m "Add weights file using LFS"
+        git push
+        ```
+
+10. **Building:** The Space will automatically start building the Docker image based on your `Dockerfile`. Monitor the build logs.
+
+11. **Running:** Once built, the application should start automatically. You can access it via the public URL provided for your Space.
+
+## Local Development (Optional)
+
+1.  **Install Docker:** Make sure you have Docker installed and running.
+2.  **Build the image:**
+    ```bash
+    docker build -t nemaquant-flask .
+    ```
+3.  **Run the container:**
+    ```bash
+    docker run -p 7860:7860 -v $(pwd)/results:/app/results nemaquant-flask
+    ```
+    *   This maps port 7860 from the container to your host machine.
+    *   It also mounts the local `results` directory into the container's `/app/results` directory, so you can easily access generated files.
+4.  Open your browser to `http://localhost:7860`.

app.py

@@ -0,0 +1,181 @@
+from flask import Flask, render_template, request, jsonify, send_from_directory
+import subprocess
+import os
+from pathlib import Path
+import uuid
+import pandas as pd # Added for CSV parsing
+from werkzeug.utils import secure_filename # Added for security
+
+app = Flask(__name__)
+# Use absolute paths for robustness within Docker/HF Spaces
+APP_ROOT = Path(__file__).parent
+UPLOAD_FOLDER = APP_ROOT / 'uploads' # Keep separate upload folder initially
+RESULT_FOLDER = APP_ROOT / 'results'
+WEIGHTS_FILE = APP_ROOT / 'weights.pt' # Assuming weights are in root
+app.config['UPLOAD_FOLDER'] = str(UPLOAD_FOLDER)
+app.config['RESULT_FOLDER'] = str(RESULT_FOLDER)
+app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'tif', 'tiff'}
+
+# Ensure upload and result folders exist
+UPLOAD_FOLDER.mkdir(parents=True, exist_ok=True)
+RESULT_FOLDER.mkdir(parents=True, exist_ok=True)
+
+def allowed_file(filename):
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/process', methods=['POST'])
+def process_images():
+    if 'files' not in request.files:
+        return jsonify({"error": "No file part"}), 400
+
+    files = request.files.getlist('files')
+    input_mode = request.form.get('input_mode', 'single') # Get from form data
+    confidence = request.form.get('confidence_threshold', '0.6') # Get from form data
+
+    if not files or files[0].filename == '':
+        return jsonify({"error": "No selected file"}), 400
+
+    # Create a unique job directory within results
+    job_id = str(uuid.uuid4())
+    job_input_dir = RESULT_FOLDER / job_id / 'input' # Save inputs within job dir
+    job_output_dir = RESULT_FOLDER / job_id / 'output' # Save outputs within job dir
+    job_input_dir.mkdir(parents=True, exist_ok=True)
+    job_output_dir.mkdir(parents=True, exist_ok=True)
+
+    saved_files = []
+    error_files = []
+
+    for file in files:
+        if file and allowed_file(file.filename):
+            filename = secure_filename(file.filename)
+            save_path = job_input_dir / filename
+            file.save(str(save_path))
+            saved_files.append(save_path)
+        elif file:
+            error_files.append(file.filename)
+
+    if not saved_files:
+         return jsonify({"error": f"No valid files uploaded. Invalid files: {error_files}"}), 400
+
+    # --- Prepare and Run nemaquant.py ---
+    # Determine input target for nemaquant.py
+    if input_mode == 'single' and len(saved_files) == 1:
+        input_target = str(saved_files[0])
+        img_mode_arg = 'file' # nemaquant uses file/dir, not single/directory
+    elif input_mode == 'directory' and len(saved_files) >= 1:
+        input_target = str(job_input_dir) # Pass the directory containing the images
+        img_mode_arg = 'dir'
+    else:
+        # Mismatch between mode and number of files
+        return jsonify({"error": f"Input mode '{input_mode}' requires {'1 file' if input_mode == 'single' else '1 or more files'}, but received {len(saved_files)}."}), 400
+
+
+    output_csv = job_output_dir / f"{job_id}_results.csv"
+    annotated_dir = job_output_dir # Save annotated images directly in job output dir
+
+    cmd = [
+        'python', str(APP_ROOT / 'nemaquant.py'),
+        '-i', input_target,
+        '-w', str(WEIGHTS_FILE), # Use absolute path
+        '-o', str(output_csv),
+        '-a', str(annotated_dir),
+        '--conf', confidence
+    ]
+
+    # We don't need --key or XY mode for this web interface initially
+
+    try:
+        print(f"Running command: {' '.join(cmd)}") # Log the command
+        # Run the script, capture output and errors
+        # Timeout might be needed for long processes on shared infrastructure like HF Spaces
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300) # 5 min timeout
+        status_log = f"NemaQuant Output:\n{result.stdout}\nNemaQuant Errors:\n{result.stderr}"
+        print(status_log) # Log script output
+
+        # --- Parse Results ---
+        if not output_csv.exists():
+             raise FileNotFoundError(f"Output CSV not found at {output_csv}")
+
+        df = pd.read_csv(output_csv)
+        # Expect columns like 'filename', 'num_eggs' (based on nemaquant.py)
+        # Find corresponding annotated images
+        results_list = []
+        for index, row in df.iterrows():
+            original_filename = row.get('filename', '')
+            num_eggs = row.get('num_eggs', 'N/A')
+            # Construct expected annotated filename (based on nemaquant.py logic)
+            stem = Path(original_filename).stem
+            suffix = Path(original_filename).suffix
+            annotated_filename = f"{stem}_annotated{suffix}"
+            annotated_path = annotated_dir / annotated_filename
+
+            results_list.append({
+                "filename": original_filename,
+                "num_eggs": num_eggs,
+                # Pass relative path within job dir for frontend URL construction
+                "annotated_filename": annotated_filename if annotated_path.exists() else None,
+            })
+
+        return jsonify({
+            "status": "success",
+            "job_id": job_id,
+            "results": results_list,
+            "log": status_log,
+            "error_files": error_files # Report files that were not processed
+        })
+
+    except subprocess.CalledProcessError as e:
+        error_message = f"Error running NemaQuant:\nExit Code: {e.returncode}\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
+        print(error_message)
+        return jsonify({"error": "Processing failed", "log": error_message}), 500
+    except subprocess.TimeoutExpired as e:
+        error_message = f"Error running NemaQuant: Process timed out after {e.timeout} seconds.\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
+        print(error_message)
+        return jsonify({"error": "Processing timed out", "log": error_message}), 500
+    except FileNotFoundError as e:
+        error_message = f"Error processing results: {e}"
+        print(error_message)
+        return jsonify({"error": "Could not find output file", "log": error_message}), 500
+    except Exception as e:
+        error_message = f"An unexpected error occurred: {str(e)}"
+        print(error_message)
+        return jsonify({"error": "An unexpected error occurred", "log": error_message}), 500
+
+
+@app.route('/results/<job_id>/<path:filename>')
+def download_file(job_id, filename):
+    # Construct the full path to the file within the job's output directory
+    # Use secure_filename on the incoming filename part for safety? Maybe not needed if we trust our generated paths.
+    # Crucially, validate job_id and filename to prevent directory traversal.
+    # A simple check: ensure job_id is a valid UUID format and filename doesn't contain '..'
+    try:
+        uuid.UUID(job_id, version=4) # Validate UUID format
+    except ValueError:
+        return "Invalid job ID format", 400
+
+    if '..' in filename or filename.startswith('/'):
+        return "Invalid filename", 400
+
+    file_dir = RESULT_FOLDER / job_id / 'output'
+    # Use send_from_directory for security (handles path joining and prevents traversal above the specified directory)
+    print(f"Attempting to send file: {filename} from directory: {file_dir}")
+    try:
+        return send_from_directory(str(file_dir), filename, as_attachment=False) # Display images inline
+    except FileNotFoundError:
+        print(f"File not found: {file_dir / filename}")
+        return "File not found", 404
+
+
+if __name__ == '__main__':
+    # Ensure weights file exists before starting
+    if not WEIGHTS_FILE.exists():
+        print(f"ERROR: Weights file not found at {WEIGHTS_FILE}")
+        print("Please ensure 'weights.pt' is in the application root directory.")
+        exit(1) # Exit if weights are missing
+
+    app.run(debug=True, host='0.0.0.0', port=7860) # Port 7860 is common for HF Spaces 

nemaquant.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import argparse
+import numpy as np
+import pandas as pd 
+import cv2
+import os
+from pathlib import Path
+from ultralytics import YOLO
+from glob import glob
+import re
+
+def options():
+    parser = argparse.ArgumentParser(description="Nematode egg image processing with YOLOv8 model.")
+    parser.add_argument("-i", "--img", help="Target image directory or image (REQUIRED)", required=True)
+    parser.add_argument('-w', '--weights', help='Weights file for use with YOLO11 model')
+    parser.add_argument("-o","--output", help="Name of results file. If no file is specified, one will be created from the key file name")
+    parser.add_argument("-k", "--key", help="CSV key file to use as output template. If no file is specified, will look for one in target directory. Not used in single-image mode")
+    parser.add_argument("-a","--annotated", help="Directory to save annotated image files", required=False)
+    parser.add_argument("--conf", help="Confidence cutoff (default = 0.6)", default=0.6, type=float)
+    args = parser.parse_args()
+    return args
+
+# TODO - maybe rework this from a function to custom argparse.Action() subclasses?
+def check_args():
+    args = options()
+    # basic checks on target file validity
+    args.imgpath = Path(args.img)
+    if not args.imgpath.exists():
+        raise Exception("Target %s is not a valid path" % args.img)
+    if args.imgpath.is_file():
+        args.img_mode = 'file'
+        if not args.imgpath.suffix.lower() in ['.tif','.tiff','.jpg','.jpeg','.png']:
+            raise Exception('Target image %s must of type .png, .tif, .tiff, .jpeg, or .jpg' % args.img)
+    elif args.imgpath.is_dir():
+        args.img_mode = 'dir'
+    else:
+        raise Exception('Target %s does not appear to be a file or directory.' % args.img)
+
+    # if no weights file, try using the default weights.pt
+    if not args.weights:
+        script_dir = Path(__file__).parent
+        default_weights = script_dir / 'weights.pt'
+        if default_weights.exists():
+            args.weights = str(default_weights)
+        else:
+            raise Exception('No weights file specified and default weights.pt not found in script directory')
+
+    # check if subdirectories of format XY00/ exist or if we're running on just a dir of images
+    if args.img_mode == 'dir':
+        subdirs = sorted(list(args.imgpath.glob('XY[0-9][0-9]/')))
+        if len(subdirs) == 0:
+            print("No subdirectories of format /XY../ found in specified imgdir, checking for images...")
+            potential_images = [x for x in args.imgpath.iterdir() if x.suffix.lower() in ['.tif','.tiff','.jpg','.jpeg','.png']]
+            if len(potential_images) == 0:
+                raise Exception('No valid images (.png, .tif, .tiff, .jpeg, .jpg) in target folder %s' % args.img)
+            else:
+                print('%s valid images found' % len(potential_images))
+                args.xy_mode = False
+                args.subimage_paths = potential_images
+        else:
+            args.xy_mode = True
+            args.subdir_paths = subdirs
+        
+        # for /XY00/ subdirectories, we require a valid key
+        # ensure that either a key is specified, or if a single .csv exists in the target dir, use that
+        if args.xy_mode:
+            if args.key:
+                args.keypath = Path(args.key)
+                if not args.keypath.exists():
+                    raise Exception('Specified key file does not exist: %s' % args.keypath)
+                if args.keypath.suffix != '.csv':
+                    raise Exception("Specified key file is not a .csv: %s" % args.keypath)
+            else:
+                print('Running on /XY00/ subdirectories but no key specified. Looking for key file...')
+                potential_keys = list(args.imgpath.glob('*.csv'))
+                if len(potential_keys) == 0:
+                    raise Exception("No .csv files found in target folder %s, please check directory" % args.img)
+                if len(potential_keys) > 1:
+                    raise Exception("Multiple .csv files found in target folder %s, please specify which one to use")
+                else:
+                    args.keypath = potential_keys[0]
+                    args.key = str(potential_keys[0])
+
+        # if path to results file is specified, ensure it is .csv
+        if args.output:
+            args.outpath = Path(args.output)
+            if args.outpath.suffix != '.csv':
+                raise Exception("Specified output file is not a .csv: %s" % args.outpath)
+        else:
+            # for XY00 subdirs, name it after the required key file
+            # for an image directory, name it after the directory
+            if args.xy_mode:
+                args.output = '%s_eggcounts.csv' % args.keypath.stem
+            else:
+                args.output = '%s_eggcounts.csv' % args.imgpath.stem
+            args.outpath = Path(args.output)
+
+    # finally, check the target dir to save annotated images in
+    if args.annotated:
+        args.annotpath = Path(args.annotated)
+        if not args.annotpath.exists():
+            os.mkdir(args.annotated)
+        elif not args.annotpath.is_dir():
+            raise Exception("annotated output folder is not a valid directory: %s" % args.annotated)   
+    return args
+
+# parse a key file, make sure it all looks correct and can be merged later
+def parse_key_file(keypath):
+    key = pd.read_csv(keypath)
+    # drop potential Unnamed: 0 column if rownames from R were included without col header
+    key = key.loc[:, ~key.columns.str.contains('^Unnamed')]
+    # for now, will only allow 96-row key files
+    # can handle edge cases, but much easier if we just require 96
+    if key.shape[0] > 96:
+        raise Exception("More than 96 rows found in key. Please check formatting and try again")
+    # check if it's got at least one column formatted with what looks like plate positions
+    well_columns = []
+    for col in key.columns:
+        if key[col].dtype.kind == "O":
+            if all(key[col].str.fullmatch("[A-H][0-9]{1,2}")):
+                well_columns.append(col)
+    if len(well_columns) == 0:
+        raise Exception("No column found with well positions of format A1/A01/H12/etc.")
+    elif len(well_columns) > 1:
+        raise Exception("Multiple columns found with well positions of format A1/A01/H12/etc.")
+    # add a column named keycol, formatted to match the folder output like _A01
+    key["keycol"] = key[well_columns[0]]
+    # as the key, it should really be unique and complete, raise exception if not the case
+    if any(key["keycol"].isna()):
+        raise Exception("There appear to be blank well positions in column %s. Please fix and resubmit." % well_columns[0])    
+    if len(set(key["keycol"])) < len(key["keycol"]):
+        raise Exception("There appear to be duplicated well positions in the key file. Please fix and resubmit.")
+    # if formatted A1, reformat as A01
+    key["keycol"] = key["keycol"].apply(lambda x: "_%s%s" % (re.findall("[A-H]",x)[0], re.findall("[0-9]+", x)[0].zfill(2)))
+    return key
+        
+def main():
+    args = check_args()
+    if args.key:
+        key = parse_key_file(str(args.keypath))
+    model = YOLO(args.weights)
+    # create a couple empty lists for holding results, easier than adding to empty Pandas DF
+    tmp_well = []
+    tmp_numeggs = []
+    tmp_filenames = []
+    # single-image mode
+    if args.img_mode == 'file':
+        img = cv2.imread(str(args.imgpath))
+        results = model.predict(img, imgsz = 1440, max_det=1000, verbose=False, conf=args.conf)
+        result = results[0]
+        box_classes = [result.names[int(x)] for x in result.boxes.cls]
+        # NOTE - filtering by class is not necessary, but would make this easier to extend to multi-class models
+        # e.g. if we want to add hatched, empty eggs, etc
+        egg_xy = [x.numpy().astype(np.int32) for i,x in enumerate(result.boxes.xyxy) if box_classes[i] == 'egg']
+        print('Target image:\n%s' % str(args.imgpath))
+        print('n eggs:\n%s' % len(egg_xy))
+        if args.annotated:
+            annot = img.copy()
+            for xy in egg_xy:
+                cv2.rectangle(annot, tuple(xy[0:2]), tuple(xy[2:4]), (0,0,255), 4)
+            annot_path = args.annotpath / ('%s_annotated%s' % (args.imgpath.stem, args.imgpath.suffix))
+            cv2.imwrite(str(annot_path), annot)
+            print('Saving annotations to %s...' % str(annot_path))
+    # multi-image mode, runs differently depending on whether you have /XY00/ subdirectories
+    elif args.img_mode == 'dir':
+        if args.xy_mode:
+            for subdir in args.subdir_paths:
+                # check that the empty file with well name is present
+                well = [x.name for x in subdir.iterdir() if re.match("_[A-H][0-9]{1,2}", x.name)][0]
+                if len(well) == 0:
+                    raise Exception("No well position file of format _A01 found in subdirectory:\n%s" % subdir)
+                # print the XY subdirectory name for tracking purposes
+                xy = subdir.name
+                print(xy)
+                # search for a filename with CH4 in it
+                # TODO - confirm with sweetpotato group that the CH4.tif or CH4.jpg will be present in all cases
+                candidate_img_paths = list(subdir.glob('*CH4*'))
+                # if none or more than one, just skip the folder vs raise exceptions
+                if len(candidate_img_paths) == 0:
+                    print("No CH4 image found for subdirectory %s" % subdir)
+                    continue
+                elif len(candidate_img_paths) > 1:
+                    print("Multiple CH4 images found in subdirectory %s" % subdir)
+                    continue
+                impath = candidate_img_paths[0]
+                # get the actual output
+                img = cv2.imread(str(impath))
+                results = model.predict(img, imgsz = 1440, verbose=False, conf=args.conf)
+                result = results[0]
+                box_classes = [result.names[int(x)] for x in result.boxes.cls]
+                egg_xy = [x.numpy().astype(np.int32) for i,x in enumerate(result.boxes.xyxy) if box_classes[i] == 'egg']
+                # append relevant output to temporary lists
+                tmp_well.append(well)
+                tmp_numeggs.append(len(egg_xy))
+                tmp_filenames.append(impath.name)
+                # annotate and save image if needed
+                if args.annotated:
+                    annot = img.copy()
+                    for xy in egg_xy:
+                        cv2.rectangle(annot, tuple(xy[0:2]), tuple(xy[2:4]), (0,0,255), 4)
+                    annot_path = args.annotpath / ('%s_annotated%s' % (impath.stem, impath.suffix))
+                    cv2.imwrite(str(annot_path), annot)
+            # make a CSV to merge with the key
+            results = pd.DataFrame({
+                "keycol": tmp_well,
+                "num_eggs": tmp_numeggs,
+                "filename": tmp_filenames,
+                "folder": args.img})
+            # merge and save
+            outdf = key.merge(results, on = "keycol", how = "left")
+            outdf = outdf.drop("keycol", axis = 1)
+        else:
+            # apply the model on each image
+            # running model() on the target dir instead of image-by-image would be cleaner
+            # but makes saving annotated images more complicated
+            # can maybe revisit later
+            for impath in sorted(args.subimage_paths):
+                img = cv2.imread(str(impath))
+                results = model.predict(img, imgsz = 1440, verbose=False, conf= args.conf)
+                result = results[0]
+                box_classes = [result.names[int(x)] for x in result.boxes.cls]
+                egg_xy = [x.numpy().astype(np.int32) for i,x in enumerate(result.boxes.xyxy) if box_classes[i] == 'egg']
+                tmp_numeggs.append(len(egg_xy))
+                tmp_filenames.append(impath.name)
+                # annotate if needed
+                if args.annotated:
+                    annot = img.copy()
+                    for xy in egg_xy:
+                        cv2.rectangle(annot, tuple(xy[0:2]), tuple(xy[2:4]), (0,0,255), 4)
+                    annot_path = args.annotpath / ('%s_annotated%s' % (impath.stem, impath.suffix))
+                    cv2.imwrite(str(annot_path), annot)
+            outdf = pd.DataFrame({
+                'folder': args.imgpath,
+                "filename": tmp_filenames,
+                "num_eggs": tmp_numeggs})
+        # save final pandas df, print some updates for user
+        outdf.sort_values(by='filename', inplace=True)
+        outdf.to_csv(str(args.outpath), index=False)
+        print('Saving output to %s...' % str(args.outpath))
+        if args.annotated:
+            print('Saving annotated images to %s...' % str(args.annotpath))
+        
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,7 @@
+PyQt6>=6.4.0
+pandas>=1.5.0
+opencv-python>=4.7.0
+numpy>=1.21.0
+ultralytics>=8.0.0
+torch>=2.0.0
+Flask>=2.0.0 

static/script.js

@@ -0,0 +1,287 @@
+// Basic front-end logic
+
+document.addEventListener('DOMContentLoaded', () => {
+    const inputMode = document.getElementById('input-mode');
+    const fileInput = document.getElementById('file-input');
+    const startProcessingBtn = document.getElementById('start-processing');
+    const confidenceSlider = document.getElementById('confidence-threshold');
+    const confidenceValue = document.getElementById('confidence-value');
+    const progress = document.getElementById('progress');
+    const progressText = document.getElementById('progress-text');
+    const processingStatus = document.getElementById('processing-status');
+    const statusOutput = document.getElementById('status-output');
+    const resultsTableBody = document.querySelector('#results-table tbody');
+    const previewImage = document.getElementById('preview-image');
+    const imageInfo = document.getElementById('image-info');
+    const prevBtn = document.getElementById('prev-image');
+    const nextBtn = document.getElementById('next-image');
+    const exportCsvBtn = document.getElementById('export-csv');
+    const exportImagesBtn = document.getElementById('export-images');
+    const zoomInBtn = document.getElementById('zoom-in');
+    const zoomOutBtn = document.getElementById('zoom-out');
+
+    let currentResults = [];
+    let currentImageIndex = -1;
+    let currentJobId = null;
+
+    // Update confidence value display
+    confidenceSlider.addEventListener('input', () => {
+        confidenceValue.textContent = confidenceSlider.value;
+    });
+
+    // Handle input mode change (single file vs multiple)
+    inputMode.addEventListener('change', () => {
+        if (inputMode.value === 'single') {
+            fileInput.removeAttribute('multiple');
+        } else {
+            fileInput.setAttribute('multiple', '');
+        }
+    });
+
+    // --- Updated Start Processing Logic ---
+    startProcessingBtn.addEventListener('click', async () => {
+        const files = fileInput.files;
+        if (!files || files.length === 0) {
+            logStatus('Error: No files selected.');
+            alert('Please select one or more image files.');
+            return;
+        }
+
+        const mode = inputMode.value;
+        if (mode === 'single' && files.length > 1) {
+            logStatus('Error: Single File mode selected, but multiple files chosen.');
+            alert('Single File mode allows only one file. Please select one file or switch to Directory mode.');
+            return;
+        }
+
+        logStatus('Starting upload and processing...');
+        processingStatus.textContent = 'Uploading...';
+        startProcessingBtn.disabled = true;
+        progress.value = 0;
+        progressText.textContent = '0%';
+        resultsTableBody.innerHTML = ''; // Clear previous results
+        clearPreview(); // Clear image preview
+
+        const formData = new FormData();
+        for (const file of files) {
+            formData.append('files', file);
+        }
+        formData.append('input_mode', mode);
+        formData.append('confidence_threshold', confidenceSlider.value);
+
+        // Basic progress simulation for upload (replace with XHR progress if needed)
+        progress.value = 50;
+        progressText.textContent = '50%';
+        processingStatus.textContent = 'Processing...';
+
+        try {
+            const response = await fetch('/process', {
+                method: 'POST',
+                body: formData,
+            });
+
+            progress.value = 100;
+            progressText.textContent = '100%';
+
+            const data = await response.json();
+
+            if (response.ok) {
+                logStatus('Processing successful.');
+                processingStatus.textContent = 'Processing finished.';
+                currentJobId = data.job_id; // Store the job ID
+                logStatus(`Job ID: ${currentJobId}`);
+                if (data.log) {
+                    logStatus("--- Server Log ---");
+                    logStatus(data.log);
+                    logStatus("--- End Log ---");
+                }
+                if (data.error_files && data.error_files.length > 0) {
+                    logStatus(`Warning: Skipped invalid files: ${data.error_files.join(', ')}`);
+                }
+                displayResults(data.results || []);
+            } else {
+                logStatus(`Error: ${data.error || 'Unknown processing error.'}`);
+                if (data.log) {
+                    logStatus("--- Server Log ---");
+                    logStatus(data.log);
+                    logStatus("--- End Log ---");
+                }
+                processingStatus.textContent = 'Error during processing.';
+                alert(`Processing failed: ${data.error || 'Unknown error'}`);
+            }
+
+        } catch (error) {
+            console.error('Fetch Error:', error);
+            logStatus(`Network or Server Error: ${error.message}`);
+            processingStatus.textContent = 'Network Error.';
+            progress.value = 0;
+            progressText.textContent = 'Error';
+            alert(`An error occurred while communicating with the server: ${error.message}`);
+        } finally {
+            startProcessingBtn.disabled = false; // Re-enable button
+        }
+    });
+
+    function logStatus(message) {
+        statusOutput.value += message + '\n';
+        statusOutput.scrollTop = statusOutput.scrollHeight; // Auto-scroll
+    }
+
+    function displayResults(results) {
+        currentResults = results; // Store results
+        resultsTableBody.innerHTML = ''; // Clear existing results
+        currentImageIndex = -1; // Reset index
+        currentJobId = currentJobId; // Ensure job ID is current
+
+        if (!results || results.length === 0) {
+            logStatus("No results returned from processing.");
+            clearPreview();
+            exportCsvBtn.disabled = true;
+            exportImagesBtn.disabled = true;
+            updateNavButtons(); // Ensure nav buttons are disabled
+            return; // Exit early
+        }
+
+        results.forEach((result, index) => {
+            const row = resultsTableBody.insertRow();
+            row.classList.add('result-row'); // Add class for styling/selection
+            row.innerHTML = `<td>${result.filename}</td><td>${result.num_eggs}</td>`;
+            // Add data attributes for easy access
+            row.dataset.index = index;
+            row.dataset.filename = result.filename;
+            row.dataset.annotatedFilename = result.annotated_filename;
+
+            row.addEventListener('click', () => {
+                displayImage(index);
+            });
+        });
+
+        displayImage(0); // Show the first image initially
+        // Enable export buttons IF there are results
+        exportCsvBtn.disabled = !results.some(r => r.filename); // Enable if at least one result has a filename
+        exportImagesBtn.disabled = !results.some(r => r.annotated_filename); // Enable if at least one result has an annotated image
+    }
+
+    function displayImage(index) {
+        if (index < 0 || index >= currentResults.length || !currentJobId) {
+            clearPreview();
+            return;
+        }
+
+        currentImageIndex = index;
+        const result = currentResults[index];
+
+        if (result.annotated_filename) {
+            const imageUrl = `/results/${currentJobId}/${result.annotated_filename}`;
+            previewImage.src = imageUrl;
+            previewImage.alt = `Annotated ${result.filename}`;
+            imageInfo.textContent = `Filename: ${result.filename} - Eggs detected: ${result.num_eggs}`;
+            logStatus(`Displaying image: ${result.annotated_filename}`);
+        } else {
+            // Handle cases where annotation failed or wasn't produced
+            previewImage.src = ''; // Clear image
+            previewImage.alt = 'Annotated image not available';
+            imageInfo.textContent = `Filename: ${result.filename} - Eggs detected: ${result.num_eggs} (Annotation N/A)`;
+            logStatus(`Annotated image not available for: ${result.filename}`);
+        }
+
+        updateNavButtons();
+
+        // Highlight selected row
+        document.querySelectorAll('.result-row').forEach(row => {
+            row.classList.remove('selected');
+        });
+        const selectedRow = resultsTableBody.querySelector(`tr[data-index="${index}"]`);
+        if (selectedRow) {
+            selectedRow.classList.add('selected');
+        }
+    }
+
+    function clearPreview() {
+        previewImage.src = '';
+        previewImage.alt = 'Annotated image preview';
+        imageInfo.textContent = 'Filename: - Eggs detected: -';
+        currentImageIndex = -1;
+        updateNavButtons();
+    }
+
+    function updateNavButtons() {
+        prevBtn.disabled = currentImageIndex <= 0;
+        nextBtn.disabled = currentImageIndex < 0 || currentImageIndex >= currentResults.length - 1;
+    }
+
+    prevBtn.addEventListener('click', () => {
+        if (currentImageIndex > 0) {
+            displayImage(currentImageIndex - 1);
+        }
+    });
+
+    nextBtn.addEventListener('click', () => {
+        if (currentImageIndex < currentResults.length - 1) {
+            displayImage(currentImageIndex + 1);
+        }
+    });
+
+    // --- Export Logic (Placeholders - requires backend implementation) ---
+    exportCsvBtn.addEventListener('click', () => {
+        if (!currentJobId) {
+            alert("No job processed yet.");
+            return;
+        }
+        // Construct the CSV download URL
+        const csvFilename = `${currentJobId}_results.csv`;
+        const downloadUrl = `/results/${currentJobId}/${csvFilename}`;
+        logStatus(`Triggering CSV download: ${csvFilename}`);
+        // Create a temporary link and click it
+        const link = document.createElement('a');
+        link.href = downloadUrl;
+        link.download = csvFilename; // Suggest filename to browser
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    });
+
+    exportImagesBtn.addEventListener('click', () => {
+        if (!currentJobId) {
+            alert("No job processed yet.");
+            return;
+        }
+        // This is more complex. Ideally, the backend would provide a zip file.
+        // For now, just log and maybe open the first image?
+        logStatus('Image export clicked. Downloading individual images or a zip file is needed.');
+        alert('Image export functionality requires backend support to create a downloadable archive (zip file).');
+        // Example: trigger download of the currently viewed image
+        if (currentImageIndex !== -1 && currentResults[currentImageIndex].annotated_filename) {
+            const imgFilename = currentResults[currentImageIndex].annotated_filename;
+            const downloadUrl = `/results/${currentJobId}/${imgFilename}`;
+            const link = document.createElement('a');
+            link.href = downloadUrl;
+            link.download = imgFilename;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    });
+
+    // --- Zoom Logic (Placeholder - requires a library or complex CSS/JS) ---
+    zoomInBtn.addEventListener('click', () => {
+        console.log('Zoom In clicked');
+        logStatus('Zoom functionality not yet implemented.');
+        alert('Zoom functionality is not yet implemented.');
+    });
+
+    zoomOutBtn.addEventListener('click', () => {
+        console.log('Zoom Out clicked');
+        logStatus('Zoom functionality not yet implemented.');
+        alert('Zoom functionality is not yet implemented.');
+    });
+
+    // Initial setup
+    if (inputMode.value === 'single') {
+        fileInput.removeAttribute('multiple');
+    }
+    logStatus('Application initialized. Ready for file selection.');
+    exportCsvBtn.disabled = true;
+    exportImagesBtn.disabled = true;
+    clearPreview(); // Ensure preview is cleared on load
+}); 

static/style.css

@@ -0,0 +1,335 @@
+/* Refined styling to better match screenshot */
+
+:root {
+    --primary-color: #0d6efd; /* Bootstrap blue */
+    --secondary-color: #6c757d; /* Bootstrap secondary grey */
+    --light-grey: #f8f9fa; /* Light background */
+    --border-color: #dee2e6; /* Standard border */
+    --card-bg: #ffffff;
+    --text-color: #212529;
+    --selected-row-bg: #e9ecef;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+    margin: 20px;
+    background-color: var(--light-grey);
+    color: var(--text-color);
+    font-size: 0.95rem;
+}
+
+h1 {
+    text-align: center;
+    color: #333;
+    margin-bottom: 25px;
+}
+
+.container {
+    display: flex;
+    gap: 25px;
+}
+
+.left-panel,
+.right-panel {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+}
+
+.card {
+    background-color: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 20px;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05);
+}
+
+.card h2 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    border-bottom: 1px solid var(--border-color);
+    padding-bottom: 10px;
+    font-size: 1.1rem;
+    font-weight: 500;
+}
+
+/* --- General Form Elements --- */
+label {
+    display: block;
+    margin-bottom: 5px;
+    font-weight: 500;
+}
+
+select,
+input[type="text"],
+input[type="number"],
+input[type="file"]::file-selector-button, /* Style the button part */
+textarea {
+    display: block;
+    width: calc(100% - 16px); /* Account for padding */
+    padding: 8px;
+    margin-bottom: 15px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 0.9rem;
+}
+
+select {
+     width: 100%; /* Select takes full width */
+     cursor: pointer;
+}
+
+/* Style the actual file input button */
+input[type="file"] {
+    padding: 0;
+    border: none;
+}
+input[type="file"]::file-selector-button {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    padding: 8px 12px;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+    margin-right: 10px; /* Space between button and text */
+    font-size: 0.9rem;
+    width: auto; /* Override width */
+}
+
+input[type="file"]::file-selector-button:hover {
+    background-color: #0b5ed7; /* Darker blue on hover */
+}
+
+/* --- Buttons --- */
+button {
+    padding: 8px 15px;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.9rem;
+    transition: background-color 0.2s ease, box-shadow 0.2s ease;
+    text-align: center;
+}
+
+button:disabled {
+    opacity: 0.65;
+    cursor: not-allowed;
+}
+
+/* Primary Button Style (e.g., Start Processing) */
+#start-processing,
+#export-csv,
+#export-images {
+    background-color: var(--primary-color);
+    color: white;
+}
+
+#start-processing:not(:disabled):hover,
+#export-csv:not(:disabled):hover,
+#export-images:not(:disabled):hover {
+    background-color: #0b5ed7; /* Darker blue */
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+/* Secondary/Control Button Style (e.g., Zoom, Prev/Next) */
+#zoom-in, #zoom-out, #prev-image, #next-image {
+    background-color: var(--secondary-color);
+    color: white;
+}
+
+#zoom-in:not(:disabled):hover, #zoom-out:not(:disabled):hover, #prev-image:not(:disabled):hover, #next-image:not(:disabled):hover {
+    background-color: #5c636a; /* Darker grey */
+}
+
+/* --- Specific Sections --- */
+
+/* Parameters */
+#parameters {
+    display: flex;
+    align-items: center; /* Align items vertically */
+    flex-wrap: wrap; /* Allow wrapping if needed */
+}
+
+#parameters label {
+    margin-right: 10px;
+    margin-bottom: 0; /* Remove bottom margin for inline */
+    display: inline-block; /* Make label inline */
+}
+
+#parameters input[type="range"] {
+    flex-grow: 1; /* Allow slider to take up space */
+    width: auto; /* Override default width */
+    height: 5px; /* Make slider thinner */
+    cursor: pointer;
+    margin: 0 10px; /* Add some margin */
+    vertical-align: middle;
+    padding: 0; /* Remove padding */
+    margin-bottom: 0;
+}
+
+/* Basic range slider styling (will vary by browser) */
+input[type=range]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  appearance: none;
+  width: 16px;
+  height: 16px;
+  background: var(--primary-color);
+  cursor: pointer;
+  border-radius: 50%;
+}
+
+input[type=range]::-moz-range-thumb {
+  width: 16px;
+  height: 16px;
+  background: var(--primary-color);
+  cursor: pointer;
+  border-radius: 50%;
+  border: none;
+}
+
+#parameters #confidence-value {
+    font-weight: bold;
+    min-width: 30px; /* Ensure space for value */
+    text-align: right;
+    margin-left: 5px;
+}
+
+/* Processing */
+#processing progress {
+    width: calc(100% - 50px); /* Adjust width to fit text */
+    height: 10px;
+    vertical-align: middle;
+    margin-right: 5px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    overflow: hidden; /* Ensure border radius clips the progress */
+}
+
+/* Basic progress bar styling */
+progress::-webkit-progress-bar {
+    background-color: #e9ecef;
+    border-radius: 4px;
+}
+
+progress::-webkit-progress-value {
+    background-color: var(--primary-color);
+    border-radius: 4px;
+    transition: width 0.3s ease;
+}
+
+progress::-moz-progress-bar {
+    background-color: var(--primary-color);
+    border-radius: 4px;
+    transition: width 0.3s ease;
+}
+
+#processing #progress-text {
+    vertical-align: middle;
+    font-weight: bold;
+}
+
+#processing button {
+    margin-top: 15px;
+    display: block; /* Make button block level */
+    width: auto;
+}
+
+#processing #processing-status {
+    margin-top: 10px;
+    font-size: 0.9em;
+    color: var(--secondary-color);
+}
+
+/* Status Log */
+#status-log textarea {
+    width: calc(100% - 16px); /* Account for padding */
+    height: 180px; /* Slightly taller */
+    font-family: monospace;
+    font-size: 0.85em;
+    border: 1px solid var(--border-color);
+    padding: 8px;
+    resize: vertical; /* Allow vertical resize */
+}
+
+/* Results Summary */
+#export-options {
+    margin-bottom: 10px;
+}
+#export-options label {
+    display: inline-block;
+    margin-right: 10px;
+}
+
+#export-options button {
+    margin-left: 5px;
+}
+
+#results-summary table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 15px;
+    font-size: 0.9em;
+}
+
+#results-summary th,
+#results-summary td {
+    border: 1px solid var(--border-color);
+    padding: 10px;
+    text-align: left;
+    vertical-align: middle;
+}
+
+#results-summary th {
+    background-color: #e9ecef; /* Lighter grey header */
+    font-weight: 600;
+}
+
+#results-summary tbody tr {
+    cursor: pointer;
+    transition: background-color 0.15s ease;
+}
+
+#results-summary tbody tr:hover {
+    background-color: #f8f9fa; /* Very light grey on hover */
+}
+
+#results-summary tbody tr.selected {
+    background-color: var(--selected-row-bg); /* Use variable for selected */
+    font-weight: 500;
+}
+
+/* Image Preview */
+#image-preview #image-container {
+    border: 1px solid var(--border-color);
+    height: 350px; /* Adjust as needed */
+    overflow: auto;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    margin-bottom: 10px;
+    background-color: #e9ecef; /* Light background for container */
+}
+
+#image-preview img {
+    max-width: 100%;
+    max-height: 100%;
+    display: block;
+    object-fit: contain; /* Ensure image fits well */
+}
+
+#image-preview #image-info {
+    font-size: 0.9em;
+    color: var(--secondary-color);
+    text-align: center;
+    margin-bottom: 10px;
+}
+
+#image-preview .image-controls {
+    text-align: center;
+}
+
+#image-preview .image-controls button {
+    margin: 0 5px;
+} 

templates/index.html

@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>NemaQuant - Nematode Egg Detection</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+    <!-- Consider adding a CSS framework like Bootstrap -->
+</head>
+<body>
+    <h1>NemaQuant - Nematode Egg Detection</h1>
+
+    <div class="container">
+        <div class="left-panel">
+            <!-- Input Selection -->
+            <div class="card" id="input-selection">
+                <h2>Input Selection</h2>
+                <label for="input-mode">Input Mode:</label>
+                <select id="input-mode" name="input-mode">
+                    <option value="single">Single File</option>
+                    <option value="directory">Directory (Multiple Files)</option>
+                </select>
+                <br>
+                <label for="file-input">Input:</label>
+                <input type="file" id="file-input" name="files" multiple>
+                <!-- We'll hide/show this or use different elements based on mode -->
+                <br>
+                <!-- Output directory is handled by the server -->
+            </div>
+
+            <!-- Processing -->
+            <div class="card" id="processing">
+                <h2>Processing</h2>
+                <label for="progress">Progress:</label>
+                <progress id="progress" value="0" max="100"></progress>
+                <span id="progress-text">0%</span>
+                <br>
+                <button id="start-processing">Start Processing</button>
+                <p id="processing-status"></p>
+            </div>
+
+            <!-- Results -->
+            <div class="card" id="results-summary">
+                <h2>Results</h2>
+                <div id="export-options">
+                     <label>Export:</label>
+                    <button id="export-csv">CSV</button>
+                    <button id="export-images">Images</button> 
+                </div>
+                <p>Click on a row to view the annotated image</p>
+                <table id="results-table">
+                    <thead>
+                        <tr>
+                            <th>filename</th>
+                            <th>num_eggs</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <!-- Results will be populated here by JavaScript -->
+                    </tbody>
+                </table>
+            </div>
+        </div>
+
+        <div class="right-panel">
+            <!-- Parameters -->
+            <div class="card" id="parameters">
+                <h2>Parameters</h2>
+                <label for="confidence-threshold">Confidence Threshold:</label>
+                <input type="range" id="confidence-threshold" name="confidence-threshold" min="0" max="1" step="0.05" value="0.6">
+                <span id="confidence-value">0.6</span>
+                <!-- Add tooltip/help icon if needed -->
+            </div>
+
+            <!-- Status -->
+            <div class="card" id="status-log">
+                <h2>Status</h2>
+                <textarea id="status-output" rows="10" readonly></textarea>
+            </div>
+
+            <!-- Image Preview -->
+            <div class="card" id="image-preview">
+                <h2>Image Preview</h2>
+                <div id="image-container">
+                     <img id="preview-image" src="" alt="Annotated image preview">
+                 </div>
+                 <p id="image-info">Filename: - Eggs detected: -</p>
+                 <div class="image-controls">
+                     <button id="zoom-out">Zoom -</button>
+                     <button id="zoom-in">Zoom +</button>
+                     <button id="prev-image" disabled>Prev</button>
+                     <button id="next-image" disabled>Next</button>
+                 </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>