transfer the repo

.bumpversion.cfg

@@ -0,0 +1,16 @@
+[bumpversion]
+current_version = 0.2.0
+commit = False
+tag = False
+
+[bumpversion:file:pyproject.toml]
+search = version = "{current_version}"
+replace = version = "{new_version}"
+
+[bumpversion:file:src/egg_segmentation_size/__init__.py]
+search = __version__ = "{current_version}"
+replace = __version__ = "{new_version}"
+
+[bumpversion:file:tests/test_egg_segmentation_size.py]
+search = __version__ == "{current_version}"
+replace = __version__ == "{new_version}"

.gitattributes

@@ -0,0 +1,5 @@
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+results/sample1.jpg filter=lfs diff=lfs merge=lfs -text
+tests/test_data/sample1.jpg filter=lfs diff=lfs merge=lfs -text
+src/egg_segmentation_size/model/egg_segmentor.pt filter=lfs diff=lfs merge=lfs -text

.github/workflows/check-file-size.yml

@@ -0,0 +1,40 @@
+name: Check File Size
+
+on:
+  pull_request:
+    branches: [master]  # Runs on PRs to the master branch
+  workflow_dispatch:  # Allows manual triggering from the Actions tab
+
+jobs:
+  check-file-size:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Get list of changed files
+        id: changed-files
+        uses: tj-actions/changed-files@v39
+
+      - name: Check file sizes
+        run: |
+          MAX_SIZE=10485760  # 10MB in bytes
+          ERROR=0
+          for file in ${{ steps.changed-files.outputs.all_changed_files }}; do
+            if [ -f "$file" ]; then
+              FILE_SIZE=$(stat -c%s "$file")
+              if [ $FILE_SIZE -gt $MAX_SIZE ]; then
+                echo "❌ File $file exceeds the 10MB limit (Size: $FILE_SIZE bytes)"
+                ERROR=1
+              fi
+            fi
+          done
+
+          if [ $ERROR -eq 1 ]; then
+            echo "❌ Some files are too large! Please use Git LFS for large files."
+            exit 1  # Blocks the PR
+          fi
+
+      - name: Success Message
+        if: success()
+        run: echo "✅ All files are within the size limit."

.github/workflows/main.yml

@@ -0,0 +1,44 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches:
+      - '**'
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+
+      - name: Install Git LFS
+        run: |
+          git lfs install
+
+      - name: Configure Git user
+        run: |
+          git config --global user.name "industoai"
+          git config --global user.email "admin@industoai.com"
+
+      - name: Track .pt files with Git LFS
+        run: |
+          git lfs track "*.pt"
+          git lfs ls-files
+
+      - name: Add remote
+        env:
+          HF: ${{ secrets.HG }}
+        run: git remote add space  https://industoai:$HF@huggingface.co/spaces/industoai/Deep-Egg-Segmentation-and-Sizing
+
+      - name: Push to hub
+        env:
+          HF: ${{ secrets.HG }}
+        run: |
+          git lfs ls-files
+          git lfs push --all space
+          git push --force space ${{ github.ref }}:main

.gitignore

@@ -0,0 +1,25 @@
+# Pycharm files
+.idea/
+src/egg_segmentation_size/__pycache__/
+
+# poetry
+poetry.lock
+
+# data files
+src/egg_segmentation_size/data/
+
+# Unit test files
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+tests/__pycache__/
+
+# mypy files
+.mypy_cache/
+
+# Probable environments files
+.env
+.venv
+env/
+venv/

.pre-commit-config.yaml

@@ -0,0 +1,75 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+default_language_version:
+    python: python3
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0  # the release, git tag, or commit you want to use
+    hooks:
+      - id: check-toml
+      - id: check-yaml
+      - id: check-json
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+      - id: no-commit-to-branch
+      - id: check-executables-have-shebangs
+      - id: check-added-large-files
+        args: ["--maxkb=2000"]
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: pretty-format-json
+        args:
+        - --autofix
+      - id: check-symlinks
+      - id: check-ast
+      - id: detect-private-key
+  - repo: https://github.com/psf/black
+    rev: 24.1.1
+    hooks:
+      - id: black
+        language: python
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.8.0
+    hooks:
+    - id: mypy
+      language: system
+      args: [--strict, --ignore-missing-imports]
+  - repo: https://github.com/pycqa/pylint
+    rev: v3.0.3
+    hooks:
+    - id: pylint
+      language: system
+  - repo: https://github.com/Lucas-C/pre-commit-hooks
+    rev: v1.5.4
+    hooks:
+    - id: forbid-crlf
+    - id: remove-crlf
+    - id: forbid-tabs
+    - id: remove-tabs
+  - repo: https://github.com/PyCQA/bandit
+    rev: 1.7.7
+    hooks:
+    - id: bandit
+      args: ["--skip=B101"]
+  - repo: https://github.com/Lucas-C/pre-commit-hooks-markup
+    rev: v1.0.1
+    hooks:
+    - id: rst-linter
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.4.0
+    hooks:
+    - id: detect-secrets
+      language: python
+      exclude: "poetry.lock"
+      # args: ['--baseline', '.secrets.baseline']
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.9.0.6
+    hooks:
+    - id: shellcheck
+      args: ["--external-sources"]
+  - repo: https://github.com/python-poetry/poetry
+    rev: '1.7.1'
+    hooks:
+    - id: poetry-check
+    - id: poetry-lock
+      args: ["--no-update"]

Dockerfile

@@ -0,0 +1,143 @@
+## syntax=docker/dockerfile:1.1.7-experimental
+
+################
+# Base builder #
+################
+FROM python:3.10-bookworm as base_build
+
+ENV \
+  # locale environment variables
+  LC_ALL=C.UTF-8 \
+  # python environemnt variables
+  PYTHONFAULTHANDLER=1 \
+  PYTHONUNBUFFERED=1 \
+  PYTHONHASHSEED=random \
+  # pip environmental variables
+  PIP_NO_CACHE_DIR=off \
+  PIP_DISABLE_PIP_VERSION_CHECK=on \
+  PIP_DEFAULT_TIMEOUT=100 \
+  # poetry version
+  POETRY_VERSION=1.5.0
+
+# Install requirements
+RUN apt-get update && apt-get install -y \
+        curl \
+        git \
+        bash \
+        build-essential \
+        libffi-dev \
+        libssl-dev \
+        tini \
+        openssh-client \
+        cargo \
+        musl-dev \
+    && apt-get autoremove -y \
+    && rm -rf /var/lib/apt/lists/* \
+    # github ssh key setting
+    && mkdir -p -m 0700 ~/.ssh && ssh-keyscan github.com | sort > ~/.ssh/known_hosts \
+    # Installing poetry and set the PATH
+    && curl -sSL https://install.python-poetry.org | python3 - \
+    && echo 'export PATH="/root/.local/bin:$PATH"' >>/root/.profile \
+    && export PATH="/root/.local/bin:$PATH" \
+    && true
+SHELL ["/bin/bash", "-lc"]
+
+# Copy poetry lock and pyproject config files to the container
+WORKDIR /pysetup
+COPY ./poetry.lock ./pyproject.toml /pysetup/
+# Install pip/wheel/virtualenv and build the wheels based on the poetry lock
+RUN --mount=type=ssh pip3 install wheel virtualenv poetry-plugin-export \
+    && poetry export -f requirements.txt --without-hashes -o /tmp/requirements.txt \
+    && pip3 wheel --wheel-dir=/tmp/wheelhouse --trusted-host 172.17.0.1 --find-links=http://172.17.0.1:3141/debian/ -r /tmp/requirements.txt \
+    && virtualenv /.venv && source /.venv/bin/activate && echo 'source /.venv/bin/activate' >>/root/.profile \
+    && pip3 install --no-deps --trusted-host 172.17.0.1 --find-links=http://172.17.0.1:3141/debian/ --find-links=/tmp/wheelhouse/ /tmp/wheelhouse/*.whl \
+    && true
+
+
+###########################
+# Production base builder #
+###########################
+FROM base_build as production_build
+# Copy entrypoint script to the container and src files to the app directory
+COPY ./docker/entrypoint.sh /docker-entrypoint.sh
+COPY . /app/
+WORKDIR /app
+# Build the wheel packages with poetry and add them to the wheelhouse
+RUN --mount=type=ssh source /.venv/bin/activate \
+    && poetry build -f wheel --no-interaction --no-ansi \
+    && cp dist/*.whl /tmp/wheelhouse \
+    && chmod a+x /docker-entrypoint.sh \
+    && true
+
+
+
+########################
+# Production Container #
+########################
+FROM python:3.10-bookworm as production
+COPY --from=production_build /tmp/wheelhouse /tmp/wheelhouse
+COPY --from=production_build /docker-entrypoint.sh /docker-entrypoint.sh
+WORKDIR /app
+# Install system level deps for running the package and install the wheels we built in the previous step.
+RUN --mount=type=ssh apt-get update && apt-get install -y \
+        bash \
+        libffi8 \
+        libgl1 \
+        tini \
+    && apt-get autoremove -y \
+    && rm -rf /var/lib/apt/lists/* \
+    && chmod a+x /docker-entrypoint.sh \
+    && WHEELFILE=`echo /tmp/wheelhouse/egg_segmentation_size-*.whl` \
+    && pip3 install --trusted-host 172.17.0.1 --find-links=http://172.17.0.1:3141/debian/ --find-links=/tmp/wheelhouse/ "$WHEELFILE"[all] \
+    && rm -rf /tmp/wheelhouse/ \
+    && true
+ENTRYPOINT ["/usr/bin/tini", "--", "/docker-entrypoint.sh"]
+
+
+
+############################
+# Development base builder #
+############################
+FROM base_build as development_build
+# Copy src to app directory
+COPY . /app
+WORKDIR /app
+# Install dependencies from poetry lock
+RUN --mount=type=ssh source /.venv/bin/activate \
+    && apt-get update && apt-get install -y libgl1 \
+    && export PIP_FIND_LINKS=http://172.17.0.1:3141/debian/ \
+    && export PIP_TRUSTED_HOST=172.17.0.1 \
+    && pip3 install nvidia-cublas-cu12 nvidia-cusparse-cu12 triton nvidia-nccl-cu12 nvidia-cudnn-cu12 nvidia-cufft-cu12 nvidia-cusolver-cu12 \
+    && poetry install --no-interaction --no-ansi \
+    && true
+
+
+
+###################
+# Tests Container #
+###################
+FROM development_build as test
+RUN --mount=type=ssh source /.venv/bin/activate \
+    && chmod a+x docker/*.sh \
+    && docker/pre_commit_init.sh \
+    && true
+ENTRYPOINT ["/usr/bin/tini", "--", "docker/entrypoint-test.sh"]
+
+
+#########################
+# Development Container #
+#########################
+FROM development_build as development
+RUN apt-get update && apt-get install -y zsh \
+    && sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" \
+    && echo "if [ \"\$NO_WHEELHOUSE\" = \"1\" ]" >>/root/.profile \
+    && echo "then" >>/root/.profile \
+    && echo "  echo \"Wheelhouse disabled\"" >>/root/.profile \
+    && echo "else">>/root/.profile \
+    && echo "  export PIP_TRUSTED_HOST=172.17.0.1" >>/root/.profile \
+    && echo "  export PIP_FIND_LINKS=http://172.17.0.1:3141/debian/" >>/root/.profile \
+    && echo "fi" >>/root/.profile \
+    && echo "source /root/.profile" >>/root/.zshrc \
+    && pip3 install git-up \
+    && true
+ENTRYPOINT ["/bin/zsh", "-l"]

README.md

@@ -0,0 +1,169 @@
+---
+title: Deep Egg Segmentation And Sizing
+emoji: 🥚📏
+colorFrom: gray
+colorTo: indigo
+sdk: streamlit
+sdk_version: 1.43.2
+app_file: app.py
+pinned: false
+license: mit
+short_description: Deep model to segment eggs in an egg shell and specify sizes
+---
+# egg-segmentation-size
+This repo segments the eggs in images and gives an estimation of their volume in cm3 and also area in pixels.
+For segmentation purposes, we used yolo11-seg model which returns the segmentation mask of the eggs in the image.
+
+For size estimation, we calculate the area of the mask (in pixel) by using **shoelace** method.
+The volume of the eggs are estimated by knowing the fact that the eggs appear as ellipsoids or circles.
+If the images are taken exactly from above the eggs, eggs would appear as circles and the volume can be calculated by using the formula of the volume of a sphere
+which is `V = 4/3 * pi * r^3` where `r` is the radius. If the eggs appear as ellipsoids, the volume would be `V = 4/3 * pi * r1 * r2^2` where `r1` and `r2` are the major and minor radius of the ellipsoid.
+We can measure those radius by related opencv functions.
+
+**NOTE:** Since the radius measurements are in pixel, we should convert them to be used for volume estimation. To do so, we need a scale_factor which depends on the
+camera characteristics. This scale factor can be defined as `scale_factor = DPI / 2.54` where `DPI` is the dots per inch of the camera. For my camera it is `11.61`
+but one can find it easily for other cameras. The result for the test sample are based on my camera specifications.
+
+## Dataset
+A dataset from real application is collected and labeled manually in YOLO-format in order to be used for training and validation purposes.
+This dataset is available [here](https://huggingface.co/datasets/industoai/Egg-Instance-Segmentation).
+The eggs are collected within different shell types and colours (the egg-shall might be transparent plastic, bright/dark carton, etc.) in order
+to make the model robust to different background condition that might be encountered in real applications.
+Right now, two classes exists in this dataset as:
+- White eggs
+- Brown eggs
+
+The segmented areas of the eggs are also specified in the dataset with polygons.
+We try to make this dataset more diverse and rich by adding more classes and more images in the future.
+
+
+### Dataset YOLO-format Structure
+The [dataset](https://huggingface.co/datasets/industoai/Egg-Instance-Segmentation) is prepared in th YOLO-format make it easier to use.
+This dataset is split into training and validation sets. The structure of the dataset to be used in YOLO models are as following:
+```
+data/
+├── images/
+│   ├── train/
+│   │   ├── sample1.jpg
+│   │   ├── ...
+│   │   ├── sample49.jpg
+│   ├── val/
+│   │   ├── sample50.jpg
+│   │   ├── sample51.jpg
+├── labels/
+│   ├── train/
+│   │   ├── sample1.txt
+│   │   ├── ...
+│   │   ├── sample49.txt
+│   ├── val/
+│   │   ├── sample50.txt
+│   │   ├── sample51.txt
+├── data.yaml
+├── train.txt
+├── val.txt
+```
+It is good to mention that although the number of images are not too much at the moment, there are many different eggs in each image which increases the
+number of samples used in the training and validation stages. The `txt` files in the labels folders contain the polygon boxes around each egg in the images as well as
+the class of egg which is white/brown.
+
+The `train.txt` and `val.txt` files contain the path to the images in the training and validation sets.
+The `data.yaml` file contains the class names, the path to the training and validation sets, and also the path to the parent `data` directory.
+
+**NOTE:** For training, it is important to change the path to **absolute path** of the main directory where the data is located (In the above tree-structure it should be the absolute path to `data` directory.)
+
+## How to Use Locally
+This repo can be used for fine-tuning the YOLO model to segment eggs and measure eggs volumes and also can be used for testing purposes with the current fine-tuned model.
+In order to use the model for training/testing purposes locally, one can first create a virtual environment and then install the requirements
+by running the `poetry install` command (Install poetry if you do not have it in your system from [here](https://python-poetry.org/docs/#installing-with-pipx).)
+
+### Fine-Tuning
+YOLO model is fine-tuned with the collected dataset. In order to find-tune the model with other egg classes or repeat the whole process,
+one can clone this repo and download the dataset from [here](https://huggingface.co/datasets/industoai/Egg-Instance-Segmentation) and put in the `src/egg_segmentation_size/data` directory.
+Then for training or fine-tuning the model, one can run the following command:
+```bash
+egg_segmentation_size -vv train --conf_path src/egg_segmentation_size/data/data.yaml --img_resize 640 --batch_size 16 --epochs 100 --device cuda
+```
+
+### Inference
+The fine-tuned model can be used for inference purposes. The model is provided in the `src/egg_segmentation_size/model` directory.
+By uploading and using the model, one can segment white/brown eggs and measure their volumes based on teh camera scale factor.
+The model can be used with the following command:
+```bash
+egg_segmentation_size -vv infer --model_path src/egg_segmentation_size/model/egg_segmentor.pt --data_path ./tests/test_data --result_path ./results --scale_factor 11.61
+```
+It is good to mention that, the `data_path` could be a directory containing images or a single image. The `result_path` is the directory where the results are saved.
+
+As an example, white and brown eggs are segmented properly in the following image:
+<p align="center">
+    <img width="800" src="./results/sample1.jpg" alt="Egg Segmentation">
+</p>
+
+
+## Hugging Face Deployment
+The repository is also deployed in [hugging face](https://huggingface.co/spaces/industoai/Deep-Egg-Segmentation-and-Sizing) in which one can upload images,
+and then the segmented white/brown eggs and their volumes will be shown.
+
+It is good to mention that you can also run the demo application locally by running the following command:
+```shell
+streamlit run app.py
+```
+and then open the browser and go to the address `http://localhost:8501`.
+
+
+## How to load Trained Model from Hugging Face
+The trained model is also uploaded to [hugging face](https://huggingface.co/industoai/Egg-Instance-Segmentation) from which one can use it as following:
+```shell
+from huggingface_hub import hf_hub_download
+from ultralytics import YOLO
+
+model_path = hf_hub_download(repo_id="industoai/Egg-Instance-Segmentation", filename="model/egg_segmentor.pt")
+model = YOLO(model_path)
+result = model("path/to/image")
+```
+Then, the uploaded model can be used for different purposes.
+
+
+## Docker Container
+To run the docker with ssh, do the following first and then based on your need select ,test, development, or production containers:
+```shell
+export DOCKER_BUILDKIT=1
+export DOCKER_SSHAGENT="-v $SSH_AUTH_SOCK:$SSH_AUTH_SOCK -e SSH_AUTH_SOCK"
+```
+### Test Container
+This container is used for testing purposes while it runs the test
+```shell
+docker build --progress plain --ssh default --target test -t egg_segmentation_docker:test .
+docker run -it --rm -v "$(pwd):/app" $(echo $DOCKER_SSHAGENT) egg_segmentation_docker:test
+```
+
+### Development Container
+This container can be used for development purposes:
+```shell
+docker build --progress plain --ssh default --target development -t egg_segmentation_docker:development .
+docker run -it --rm -v "$(pwd):/app" -v /tmp:/tmp $(echo $DOCKER_SSHAGENT) egg_segmentation_docker:development
+```
+
+### Production Container
+This container can be used for production purposes:
+```shell
+docker build --progress plain --ssh default --target production -t egg_segmentation_docker:production .
+docker run -it --rm -v "$(pwd):/app" -v /tmp:/tmp $(echo $DOCKER_SSHAGENT) egg_segmentation_docker:production egg_segmentation_size -vv infer --model_path src/egg_segmentation_size/model/egg_segmentor.pt --data_path ./tests/test_data --result_path ./results --scale_factor 11.61
+```
+
+
+
+
+## How to Develop
+Do the following only once after creating your project:
+- Init the git repo with `git init`.
+- Add files with `git add .`.
+- Then `git commit -m 'initialize the project'`.
+- Add remote url with `git remote add origin REPO_URL`.
+- Then `git branch -M master`.
+- `git push origin master`.
+Then create a branch with `git checkout -b BRANCH_NAME` for further developments.
+- Install poetry if you do not have it in your system from [here](https://python-poetry.org/docs/#installing-with-pipx).
+- Create a virtual env preferably with virtualenv wrapper and `mkvirtualenv -p $(which python3.10) ENVNAME`.
+- Then `git add poetry.lock`.
+- Then `pre-commit install`.
+- For applying changes use `pre-commit run --all-files`.

app.py

@@ -0,0 +1,105 @@
+"""This is a demo for running the egg segmentation and sizing using streamlit library"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import tempfile
+
+import streamlit as st
+import pandas as pd
+from PIL import Image
+
+
+from src.egg_segmentation_size.segmentor import EggSegmentorInference
+
+
+@dataclass
+class DemoEggSegmentationSizing:
+    """Class for running the egg segmentation and sizing app using Streamlit."""
+
+    image: str = field(init=False)
+    scale_factor: float = field(default=11.61)
+
+    def upload_image(self) -> None:
+        """Upload an image from the streamlit page"""
+        uploaded_file = st.file_uploader(
+            "Upload an image or use the default one...", type=["jpg", "png", "jpeg"]
+        )
+        if uploaded_file is not None:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp_file:
+                tmp_file.write(uploaded_file.getbuffer())
+            self.image = tmp_file.name
+        else:
+            self.image = "tests/test_data/sample1.jpg"
+        st.image(
+            Image.open(self.image),
+            caption="Original/Uploaded Image",
+            use_container_width=True,
+        )
+        self.scale_factor = st.number_input(
+            "Choose the scale factor based on your camera for volume calculation as `factor=DPI/2.54` "
+            "(For [this dataset](https://huggingface.co/datasets/afshin-dini/Egg-Instance-Segmentation) is 11.61):",
+            value=11.61,
+            step=0.01,
+        )
+
+    def process_image(self) -> None:
+        """Process the image for the egg segmentation and sizing"""
+        if st.button("Segment/Size Eggs"):
+            inferer = EggSegmentorInference(
+                model_path=Path("./src/egg_segmentation_size/model/egg_segmentor.pt"),
+                result_path="",
+                scale_factor=self.scale_factor,
+            )
+            segmentations = inferer.inference(data_path=self.image)
+
+            result_image = inferer.result_images(segmentations)
+            st.markdown("<h3>Segmented Results</h3>", unsafe_allow_html=True)
+            st.image(
+                result_image[0], caption="Segmented Eggs", use_container_width=True
+            )
+
+            res = inferer.results_detail(segmentations)
+
+            extracted_data = []
+            if res:
+                for key, val in res.items():
+                    for detection in val:
+                        extracted_data.append(
+                            {
+                                "Image": key,
+                                "Type": detection["class"],
+                                "Area in pixel": detection["areas in pixel"],
+                                "Volume in cm3": detection["volume in cm3"],
+                            }
+                        )
+            extracted_data = pd.DataFrame(extracted_data).round(2)
+
+            st.markdown('<div class="center-container">', unsafe_allow_html=True)
+            st.markdown(
+                "<h3>Detailed Information of Segmentations</h3>", unsafe_allow_html=True
+            )
+            st.markdown(
+                """
+                <style>
+                table {
+                    width: 100%;
+                }
+                th, td {
+                    text-align: center !important;
+                }
+                </style>
+                """,
+                unsafe_allow_html=True,
+            )
+            st.table(extracted_data)
+            st.markdown("</div>", unsafe_allow_html=True)
+
+    def design_page(self) -> None:
+        """Design the streamlit page for eg detector and counter"""
+        st.title("Egg segmentor and sizer")
+        self.upload_image()
+        self.process_image()
+
+
+demo = DemoEggSegmentationSizing()
+demo.design_page()

docker/entrypoint-test.sh

@@ -0,0 +1,15 @@
+#!/bin/bash -l
+set -e
+if [ "$#" -eq 0 ]; then
+  # Kill cache, pytest complains about it if running local and docker tests in mapped volume
+  find tests  -type d -name '__pycache__' -print0 | xargs -0 rm -rf {}
+  # Make sure the service itself is installed
+  poetry install
+  # Make sure pre-commit checks were not missed and run tests
+  git config --global --add safe.directory /app
+  poetry run pre-commit install
+  pre-commit run --all-files
+  pytest -v --junitxml=pytest.xml tests/
+else
+  exec "$@"
+fi

docker/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/bin/bash -l
+set -e
+if [ "$#" -eq 0 ]; then
+  exec egg_segmentation_size --help
+else
+  exec "$@"
+fi

docker/pre_commit_init.sh

@@ -0,0 +1,10 @@
+#!/bin/bash -l
+if [ ! -d .git ]
+then
+  git init
+  git checkout -b precommit_init
+  git add .
+fi
+set -e
+poetry run pre-commit install
+SKIP="poetry-lock" poetry run pre-commit run --all-files

pyproject.toml

@@ -0,0 +1,61 @@
+[tool.poetry]
+name = "egg_segmentation_size"
+version = "0.2.0"
+description = "This repo segments the eggs in images and gives an estimation for their sizes"
+authors = ["Afshin Dini <Afshin Dini>"]
+readme = "README.md"
+packages = [{include = "egg_segmentation_size", from = "src"}]
+
+[tool.poetry.scripts]
+egg_segmentation_size = "egg_segmentation_size.main:egg_segmentation_size_cli"
+
+[tool.pylint.format]
+max-line-length=150     # This defines the maximum number of characters on a single line in pylint
+
+[tool.pylint.design]
+max-attributes=10
+max-positional-arguments=6
+max-args=6
+
+[tool.pylint.messages_control]
+disable=["fixme"]
+
+[tool.pylint.similarities]
+min-similarity-lines = 8    # Minimum lines number of a similarity.
+ignore-imports = true       # Ignore imports when computing similarities.
+
+[tool.pytest.ini_options]
+junit_family="xunit2"
+addopts="--cov=egg_segmentation_size --cov-fail-under=65 --cov-branch"
+asyncio_mode="strict"
+
+
+[tool.coverage.run]
+omit = ["tests/*"]
+branch = true
+
+
+[tool.poetry.dependencies]
+python = "^3.10"
+click = "^8.1.7"
+ultralytics = "^8.3.94"
+streamlit = "^1.43.2"
+opencv-python = "^4.11.0.86"
+pandas = "^2.2.3"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.3"
+coverage = "^7.6"
+pytest-cov = "^6.0"
+pylint = "^3.3.1"
+black = "^24.10.0"
+mypy = "^1.13.0"
+bump2version = "^1.0.1"
+bandit = "^1.7.10"
+pre-commit = "^4.0.1"
+detect-secrets = "^1.5"
+
+[build-system]
+requires = ["poetry-core>=1.5.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,75 @@
+altair==5.5.0 ; python_version >= "3.10" and python_version < "4.0"
+attrs==25.3.0 ; python_version >= "3.10" and python_version < "4.0"
+blinker==1.9.0 ; python_version >= "3.10" and python_version < "4.0"
+cachetools==5.5.2 ; python_version >= "3.10" and python_version < "4.0"
+certifi==2025.1.31 ; python_version >= "3.10" and python_version < "4.0"
+charset-normalizer==3.4.1 ; python_version >= "3.10" and python_version < "4.0"
+click==8.1.8 ; python_version >= "3.10" and python_version < "4.0"
+colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0" and platform_system == "Windows"
+contourpy==1.3.1 ; python_version >= "3.10" and python_version < "4.0"
+cycler==0.12.1 ; python_version >= "3.10" and python_version < "4.0"
+filelock==3.18.0 ; python_version >= "3.10" and python_version < "4.0"
+fonttools==4.56.0 ; python_version >= "3.10" and python_version < "4.0"
+fsspec==2025.3.0 ; python_version >= "3.10" and python_version < "4.0"
+gitdb==4.0.12 ; python_version >= "3.10" and python_version < "4.0"
+gitpython==3.1.44 ; python_version >= "3.10" and python_version < "4.0"
+idna==3.10 ; python_version >= "3.10" and python_version < "4.0"
+jinja2==3.1.6 ; python_version >= "3.10" and python_version < "4.0"
+jsonschema-specifications==2024.10.1 ; python_version >= "3.10" and python_version < "4.0"
+jsonschema==4.23.0 ; python_version >= "3.10" and python_version < "4.0"
+kiwisolver==1.4.8 ; python_version >= "3.10" and python_version < "4.0"
+markupsafe==3.0.2 ; python_version >= "3.10" and python_version < "4.0"
+matplotlib==3.10.1 ; python_version >= "3.10" and python_version < "4.0"
+mpmath==1.3.0 ; python_version >= "3.10" and python_version < "4.0"
+narwhals==1.32.0 ; python_version >= "3.10" and python_version < "4.0"
+networkx==3.4.2 ; python_version >= "3.10" and python_version < "4.0"
+numpy==2.1.1 ; python_version >= "3.10" and python_version < "4.0"
+nvidia-cublas-cu12==12.4.5.8 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cuda-cupti-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cuda-nvrtc-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cuda-runtime-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cudnn-cu12==9.1.0.70 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cufft-cu12==11.2.1.3 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-curand-cu12==10.3.5.147 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cusolver-cu12==11.6.1.9 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cusparse-cu12==12.3.1.170 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-cusparselt-cu12==0.6.2 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-nccl-cu12==2.21.5 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-nvjitlink-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+nvidia-nvtx-cu12==12.4.127 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+opencv-python==4.11.0.86 ; python_version >= "3.10" and python_version < "4.0"
+packaging==24.2 ; python_version >= "3.10" and python_version < "4.0"
+pandas==2.2.3 ; python_version >= "3.10" and python_version < "4.0"
+pillow==11.1.0 ; python_version >= "3.10" and python_version < "4.0"
+protobuf==5.29.4 ; python_version >= "3.10" and python_version < "4.0"
+psutil==7.0.0 ; python_version >= "3.10" and python_version < "4.0"
+py-cpuinfo==9.0.0 ; python_version >= "3.10" and python_version < "4.0"
+pyarrow==19.0.1 ; python_version >= "3.10" and python_version < "4.0"
+pydeck==0.9.1 ; python_version >= "3.10" and python_version < "4.0"
+pyparsing==3.2.1 ; python_version >= "3.10" and python_version < "4.0"
+python-dateutil==2.9.0.post0 ; python_version >= "3.10" and python_version < "4.0"
+pytz==2025.1 ; python_version >= "3.10" and python_version < "4.0"
+pyyaml==6.0.2 ; python_version >= "3.10" and python_version < "4.0"
+referencing==0.36.2 ; python_version >= "3.10" and python_version < "4.0"
+requests==2.32.3 ; python_version >= "3.10" and python_version < "4.0"
+rpds-py==0.23.1 ; python_version >= "3.10" and python_version < "4.0"
+scipy==1.15.2 ; python_version >= "3.10" and python_version < "4.0"
+seaborn==0.13.2 ; python_version >= "3.10" and python_version < "4.0"
+setuptools==77.0.3 ; python_version >= "3.12" and python_version < "4.0"
+six==1.17.0 ; python_version >= "3.10" and python_version < "4.0"
+smmap==5.0.2 ; python_version >= "3.10" and python_version < "4.0"
+streamlit==1.43.2 ; python_version >= "3.10" and python_version < "4.0"
+sympy==1.13.1 ; python_version >= "3.10" and python_version < "4.0"
+tenacity==9.0.0 ; python_version >= "3.10" and python_version < "4.0"
+toml==0.10.2 ; python_version >= "3.10" and python_version < "4.0"
+torch==2.6.0 ; python_version >= "3.10" and python_version < "4.0"
+torchvision==0.21.0 ; python_version >= "3.10" and python_version < "4.0"
+tornado==6.4.2 ; python_version >= "3.10" and python_version < "4.0"
+tqdm==4.67.1 ; python_version >= "3.10" and python_version < "4.0"
+triton==3.2.0 ; platform_system == "Linux" and platform_machine == "x86_64" and python_version >= "3.10" and python_version < "4.0"
+typing-extensions==4.12.2 ; python_version >= "3.10" and python_version < "4.0"
+tzdata==2025.2 ; python_version >= "3.10" and python_version < "4.0"
+ultralytics-thop==2.0.14 ; python_version >= "3.10" and python_version < "4.0"
+ultralytics==8.3.94 ; python_version >= "3.10" and python_version < "4.0"
+urllib3==2.3.0 ; python_version >= "3.10" and python_version < "4.0"
+watchdog==6.0.0 ; python_version >= "3.10" and python_version < "4.0" and platform_system != "Darwin"

src/egg_segmentation_size/__init__.py

@@ -0,0 +1,3 @@
+""" This repo segments the eggs in images and gives an estimation for their sizes """
+
+__version__ = "0.2.0"

src/egg_segmentation_size/logging.py

@@ -0,0 +1,30 @@
+"""Logger initialization"""
+
+import logging
+import logging.config
+from typing import Any
+
+
+def config_logger(loglevel: int) -> Any:
+    """Initialize a custom logger"""
+    default_logging_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "standard": {
+                "format": "%(asctime)s - [%(levelname)s] [%(name)s.%(funcName)s:%(lineno)d (%(process)d)] | %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            },
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "formatter": "standard",
+            },
+        },
+        "root": {
+            "handlers": ["console"],
+            "level": loglevel,
+        },
+    }
+    logging.config.dictConfig(default_logging_config)

src/egg_segmentation_size/main.py

@@ -0,0 +1,120 @@
+"""Run the main code for egg-segmentation-size"""
+
+from pathlib import Path
+import logging
+
+import click
+
+from egg_segmentation_size import __version__
+from egg_segmentation_size.logging import config_logger
+from egg_segmentation_size.segmentor import EggSegmentorTrainer, EggSegmentorInference
+
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+@click.version_option(version=__version__)
+@click.option(
+    "-v",
+    "--verbose",
+    count=True,
+    help="Shorthand for info/debug/warning/error loglevel (-v/-vv/-vvv/-vvvv)",
+)
+def egg_segmentation_size_cli(verbose: int) -> None:
+    """This repo segments the eggs in images and gives an estimation for their sizes"""
+    if verbose == 1:
+        log_level = 10
+    elif verbose == 2:
+        log_level = 20
+    elif verbose == 3:
+        log_level = 30
+    else:
+        log_level = 40
+    config_logger(log_level)
+
+    click.echo("Run the main code.")
+
+
+@egg_segmentation_size_cli.command()
+@click.option("--img_resize", type=int, default=640, help="Resize images to this size.")
+@click.option(
+    "--conf_path",
+    type=str,
+    default="src/egg_segmentation_size/data/data.yaml",
+    help="Path to the config file",
+)
+@click.option(
+    "--epochs", type=int, default=100, help="Number of epochs used in training."
+)
+@click.option("--batch_size", type=int, default=16, help="Batch size used in training.")
+@click.option(
+    "--device", type=str, default="cuda", help="Use cuda or cpu for training."
+)
+def train(
+    img_resize: int, conf_path: str, epochs: int, batch_size: int, device: str
+) -> None:
+    """This the CLI for training purposes"""
+    segmentation = EggSegmentorTrainer(
+        conf=conf_path,
+        img_size=img_resize,
+        epochs=epochs,
+        device=device,
+        batch_size=batch_size,
+    )
+    segmentation.train()
+    _ = segmentation.validation()
+    segmentation.model_export()
+
+
+@egg_segmentation_size_cli.command()
+@click.option(
+    "--model_path",
+    type=click.Path(),
+    default=Path("./src/egg_segmentation_size/model/egg_segmentor.pt"),
+    help="Path to the pre-trained model.",
+)
+@click.option(
+    "--data_path",
+    type=click.Path(),
+    default=Path("./tests/test_data"),
+    help="Path to the test data.",
+)
+@click.option(
+    "--result_path", type=str, default="./results", help="Path to the results."
+)
+@click.option(
+    "--scale_factor",
+    type=float,
+    default=11.61,
+    help="This is the scale factor of the camera to calculate the volume of eggs, scale_factor=DPI/2.54",
+)
+def infer(
+    model_path: Path, data_path: str, result_path: str, scale_factor: float
+) -> None:
+    """This the CLI for testing purposes"""
+    logger.info("Testing the YOLO model for egg detection...")
+    inferer = EggSegmentorInference(
+        model_path=Path(model_path), result_path=result_path, scale_factor=scale_factor
+    )
+    segmentations = inferer.inference(data_path=data_path)
+    counts = inferer.number_of_eggs(segmentations)
+    if counts:
+        for key, val in counts.items():
+            logger.info(
+                "%s eggs are detected in %s as: %s",
+                sum(item["count"] for item in val),
+                key,
+                val,
+            )
+    res = inferer.results_detail(segmentations)
+    if res:
+        for key, val in res.items():
+            for detection in val:
+                logger.info(
+                    "In image %s an egg with type: %s, and area(pixel): %d, and volume(cm3) %.2f was detected.",
+                    key,
+                    detection["class"],
+                    detection["areas in pixel"],
+                    detection["volume in cm3"],
+                )

src/egg_segmentation_size/model/egg_segmentor.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cceea6d26db8ef8dce1151d7c714270f3f9a1cb3afdd591faf0fa351459a7858
+size 6777261

src/egg_segmentation_size/segmentor.py

@@ -0,0 +1,142 @@
+"""This is the code for training the YOLO model for egg segmentation."""
+
+import logging
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Any, Optional, Mapping, List
+
+from collections import Counter
+from ultralytics import YOLO
+import numpy as np
+import cv2
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EggSegmentorTrainer:
+    """Class for training the YOLO model for egg segmentation."""
+
+    conf: str = field(default="src/egg_segmentation_size/data/data.yaml")
+    epochs: int = field(default=100)
+    img_size: int = field(default=640)
+    batch_size: int = field(default=16)
+    device: str = field(default="cuda")
+    model: Any = field(init=False)
+
+    def train(self) -> None:
+        """Train the YOLO model for egg segmentation."""
+        logger.info("Start training the YOLO model for egg segmentation.")
+        self.model = YOLO("yolov8n-seg.pt")
+        self.model.train(
+            data=self.conf,
+            epochs=self.epochs,
+            imgsz=self.img_size,
+            batch=self.batch_size,
+            device=self.device,
+        )
+
+    def validation(self) -> Any:
+        """Validate the YOLO model for egg segmentation."""
+        logger.info("Validating the YOLO model for egg segmentation.")
+        return self.model.val()
+
+    def model_export(self) -> None:
+        """Export the YOLO model for egg segmentation."""
+        logger.info("Exporting the YOLO model for egg segmentation.")
+        self.model.export(format="onnx")
+
+
+@dataclass
+class EggSegmentorInference:
+    """Class for testing the YOLO model for egg segmentation."""
+
+    model_path: Optional[Any] = field(default=None)
+    result_path: Optional[str] = field(default=None)
+    scale_factor: float = field(default=11.61)
+
+    def __post_init__(self) -> None:
+        """Post-initialization method for EggSegmentorInference."""
+        if self.model_path is None or not self.model_path.exists():
+            raise ValueError("Model does not exist or the path is not correct.")
+
+    def load_model(self) -> Any:
+        """Load the YOLO model for egg detection."""
+        logger.info("Loading the trained model for egg segmentation.")
+        return YOLO(self.model_path)
+
+    def inference(self, data_path: str) -> Any:
+        """Inference code for egg segmentation"""
+        if not Path(data_path).exists():
+            logger.error("Data path does not exist or the path is not correct.")
+        model = self.load_model()
+        results = model(
+            data_path,
+            save=False if not self.result_path else True,  # pylint: disable=R1719
+            project=self.result_path,
+            name="detections",
+        )
+        return results
+
+    @staticmethod
+    def _shoelace_area(polygon: Any) -> float:
+        """Calculate the area of a polygon using the shoelace formula."""
+        x, y = polygon[:, 0], polygon[:, 1]
+        return float(0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1))))
+
+    @staticmethod
+    def number_of_eggs(detections: Any) -> Mapping[str, Any]:
+        """Count the number of eggs detected."""
+        counts = {}
+        for result in detections:
+            class_count = Counter(int(box.cls.item()) for box in result.boxes)
+            temp = []
+            for name, count in class_count.items():
+                temp.append({"class": result.names[name], "count": count})
+            file_name = Path(result.path).name
+            counts[str(file_name)] = temp
+        return counts
+
+    def _egg_volume(self, polygon: Any, circularity_thr: int = 15) -> float:
+        """Calculate the volume of eggs based on the detected polygon for each egg."""
+        polygon = polygon.reshape((-1, 1, 2))
+        ellipse = cv2.fitEllipse(polygon)  # pylint: disable=E1101
+        minor_axis, major_axis = (
+            ellipse[1][0] / self.scale_factor,
+            ellipse[1][1] / self.scale_factor,
+        )
+
+        if (major_axis - minor_axis) > circularity_thr:
+            return 4 * np.pi * (major_axis / 2) * ((minor_axis / 2) ** 2) / 3000
+        return 4 * np.pi * (((major_axis + minor_axis) / 4) ** 3) / 3000
+
+    def results_detail(self, detections: Any) -> Mapping[str, Any]:
+        """Get the detailed results of the segmented eggs such as bounding boxes, class names, and confidences."""
+        results = {}
+        for result in detections:
+            temp = []
+            if result.masks is not None:
+                boxes = result.boxes
+                masks = result.masks.xy
+                for i, mask in enumerate(masks):
+                    polygon = np.array(mask, dtype=np.float32)
+                    temp.append(
+                        {
+                            "class": result.names[int(boxes.cls[i].item())],
+                            "confidence": boxes.conf[i].item(),
+                            "areas in pixel": self._shoelace_area(polygon),
+                            "volume in cm3": self._egg_volume(polygon),
+                        }
+                    )
+                file_name = Path(result.path).name
+                results[str(file_name)] = temp
+        return results
+
+    @staticmethod
+    def result_images(detections: Any) -> List[Any]:
+        """Make a list of the result images with detections."""
+        images = []
+        for result in detections:
+            images.append(np.array(result.plot())[:, :, [2, 1, 0]])
+        return images

tests/test_logging.py

@@ -0,0 +1,14 @@
+"""Unit test to test logging"""
+
+import logging
+from egg_segmentation_size.logging import config_logger
+
+logger = logging.getLogger(__name__)
+
+
+def test_config_logger() -> None:
+    """Unit test to test the logger"""
+    config_logger(10)
+    assert logger.name == "tests.test_logging"
+    assert logger.root.level == 10
+    assert logger.handlers == []

tests/test_main.py

@@ -0,0 +1,38 @@
+"""Package level tests"""
+
+from click.testing import CliRunner
+
+from egg_segmentation_size import __version__
+from egg_segmentation_size.main import egg_segmentation_size_cli
+
+
+def test_version() -> None:
+    """Unit test for checking the version of the code"""
+    assert __version__ == "0.2.0"
+
+
+def test_egg_segmentation_size_cli() -> None:
+    """Unit test for checking the CLI for egg segmentation sizing"""
+    runner = CliRunner()
+    result = runner.invoke(egg_segmentation_size_cli, ["--help"])
+    assert result.exit_code == 0
+    assert result
+
+
+def test_train() -> None:
+    """Unit test for training the YOLO model for egg segmentation"""
+    runner = CliRunner()
+    result = runner.invoke(egg_segmentation_size_cli, ["train", "--help"])
+    assert result.exit_code == 0
+    assert result
+
+
+def test_infer() -> None:
+    """Unit test for testing the YOLO model for egg segmentation"""
+    runner = CliRunner()
+    result = runner.invoke(
+        egg_segmentation_size_cli,
+        ["infer", "--data_path", "./tests/test_data/sample1.jpg", "--result_path", ""],
+    )
+    assert result.exit_code == 0
+    assert result

tests/test_segmentor.py

@@ -0,0 +1,47 @@
+"""Test the segmentor module."""
+
+from pathlib import Path
+import pytest
+from ultralytics import YOLO
+from egg_segmentation_size.segmentor import EggSegmentorInference
+
+
+@pytest.fixture(name="infer_function")
+def fixture_infer_function() -> EggSegmentorInference:
+    """Fixture to create an EggInference instance before each test."""
+    return EggSegmentorInference(
+        model_path=Path("./src/egg_segmentation_size/model/egg_segmentor.pt"),
+        result_path="",
+    )
+
+
+def test_load_model(infer_function: EggSegmentorInference) -> None:
+    """Test the EggInference class."""
+    model = infer_function.load_model()
+    assert isinstance(model, YOLO)
+
+
+def test_inference(infer_function: EggSegmentorInference) -> None:
+    """Test the inference method of EggInference class."""
+    result = infer_function.inference(data_path="./tests/test_data/sample1.jpg")
+    assert result
+
+
+def test_number_of_eggs(infer_function: EggSegmentorInference) -> None:
+    """Test the number of eggs detected."""
+    result = infer_function.inference(data_path="./tests/test_data/sample1.jpg")
+    counts = infer_function.number_of_eggs(result)
+    if counts:
+        for key, val in counts.items():
+            assert sum(item["count"] for item in val) == 3
+            assert key == "sample1.jpg"
+            assert val == [
+                {"class": "White-Egg", "count": 3},
+            ]
+
+
+def test_result_images(infer_function: EggSegmentorInference) -> None:
+    """Test the result_images method of EggInference class."""
+    result = infer_function.inference(data_path="./tests/test_data/sample1.jpg")
+    result_images = infer_function.result_images(result)
+    assert result_images