Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/sd338/fractureai
This tool helps people upload X-rays to find broken bones. It uses a machine to mark where the breaks are and gives users marked pictures to download. A smart computer also helps people understand their broken bones and gives them advice.
https://github.com/sd338/fractureai
css cv2 flask gorq html javascript matplotlib npm numpy pandas pydantic python react scikit-learn torch torchvision ultralytics
Last synced: 4 days ago
JSON representation
This tool helps people upload X-rays to find broken bones. It uses a machine to mark where the breaks are and gives users marked pictures to download. A smart computer also helps people understand their broken bones and gives them advice.
- Host: GitHub
- URL: https://github.com/sd338/fractureai
- Owner: Sd338
- License: mit
- Created: 2024-10-04T06:43:12.000Z (3 months ago)
- Default Branch: main
- Last Pushed: 2024-10-25T14:28:35.000Z (about 2 months ago)
- Last Synced: 2024-10-25T17:39:12.862Z (about 2 months ago)
- Topics: css, cv2, flask, gorq, html, javascript, matplotlib, npm, numpy, pandas, pydantic, python, react, scikit-learn, torch, torchvision, ultralytics
- Language: Python
- Homepage: https://huggingface.co/spaces/sd711/Fracture_AI
- Size: 287 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# FractureAI 🩺✨
## Overview 🌟
**FractureAI** is a smart web application that helps doctors find and understand fractures in X-ray images. It uses advanced technology to analyze the images, highlight the broken bones, and create detailed reports about the fractures. This tool makes it easier for healthcare professionals to diagnose and treat patients quickly and accurately. FractureAI is user-friendly, allowing anyone to upload images and get instant results without needing technical knowledge.
## Features 🌈
- **User-Friendly Interface**: Simple design to upload and analyze images.
- **Fast Fracture Detection**: Uses YOLOv8 for quick identification of fractures.
- **Detailed Analysis Reports**: Generates reports with insights about detected fractures.
- **Supports Multiple Users**: Efficiently handles many users at once without delays.
## Project Structure 📂
Here's a quick look at how the project is organized:
```
FractureAI/
│
├── backend/ # Backend logic for the FractureAI project
│ ├── app/ # Main backend application directory
│ │ ├── __init__.py # Makes the 'app' directory a package
│ │ ├── main.py # Main FastAPI application file
│ │ ├── api/ # API-related files (endpoints)
│ │ │ ├── __init__.py # Makes the 'api' directory a package
│ │ │ ├── endpoints.py # API route definitions for serving requests
│ │ ├── models/ # Model-related files
│ │ │ ├── yolo.py # YOLO model integration and functionality
│ │ │ ├── llama.py # LLAMA model integration and functionality
│ │ ├── core/ # Core application helpers and configs
│ │ │ ├── config.py # Configuration settings for the backend
│ │ │ ├── helpers.py # Helper functions used across the backend
│ │ ├── utils/ # Utility functions and classes
│ │ │ ├── image_processing.py # Functions for image processing (loading, preprocessing)
│ │ │ ├── database.py # Database-related utilities (if needed)
│ │ ├── static/ # Static files like images, CSS, JS
│ │ │ └── sample_xray.jpg # Example sample X-ray image for testing
│ ├── tests/ # Unit and integration tests for the backend
│ │ ├── test_api.py # Test cases for the API endpoints
│ │ ├── test_model.py # Test cases for model integration and outputs
│
├── huggingface/ # Hugging Face-specific logic for the project
│ ├── spaces/ # Hugging Face Spaces deployment files
│ │ ├── app.py # Main script for deploying on Hugging Face Spaces
│ │ ├── requirements.txt # Dependencies required by Hugging Face Spaces
│ ├── models/ # Hugging Face-related model files
│ │ ├── llama_model.py # Hugging Face LLAMA model handling
│ ├── utils/ # Utility functions specific to Hugging Face
│ │ ├── helpers.py # Helper functions for Hugging Face usage
│
├── vercel/ # Vercel-specific logic for serverless backend
│ ├── api/ # API files for Vercel deployment (serverless functions)
│ │ ├── index.py # Main handler for Vercel functions
│ ├── config/ # Configuration files for Vercel
│ │ ├── vercel.json # Vercel configuration settings (routing, etc.)
│ ├── utils/ # Utility functions for Vercel
│ │ ├── helpers.py # Vercel-specific helper functions
│
├── training/ # Model training and dataset management
│ ├── datasets/ # Folder for datasets used for training models
│ │ ├── custom_data/ # Custom dataset for training the fracture detection models
│ │ │ ├── images/ # Images used for training (input)
│ │ │ ├── annotations/ # Annotations for the images (output)
│ ├── scripts/ # Scripts to manage training, preprocessing, and evaluation
│ │ ├── preprocess.py # Preprocess images and annotations for training
│ │ ├── train_yolo.py # Script to train the YOLO model
│ │ ├── evaluate.py # Script to evaluate model performance after training
│ ├── configs/ # Configuration files for training models
│ │ ├── yolo_config.yaml # YOLO model configuration file for training parameters
│ ├── outputs/ # Model outputs (checkpoints, logs)
│ │ ├── model_checkpoints/ # Directory to store trained model checkpoints
│ │ ├── logs/ # Directory to store training logs
│
├── frontend/ # Frontend logic for FractureAI (Vercel/Vue/React)
│ ├── public/ # Public assets (e.g., HTML, images)
│ │ ├── index.html # Main HTML page
│ ├── src/ # Source code for the frontend components
│ │ ├── components/ # React components used in the app
│ │ │ ├── ImageUploader.jsx # Component for uploading images
│ │ │ ├── ResultsDisplay.jsx # Component for displaying results after image processing
│ │ ├── styles/ # Stylesheets for the app
│ │ │ ├── App.css # Main stylesheet for the frontend
│ │ ├── App.jsx # Main React app component
│ │ ├── index.js # Entry point for React app
│
├── requirements.txt # Python dependencies for the entire project
├── package.json # Node.js dependencies for the frontend
├── README.md # Project documentation
├── .gitignore # Git ignore file to exclude files from version control
└── LICENSE # Project license file
```
## Getting Started 🚀
### Prerequisites 📋
Ensure you have the following installed:
- Python 3.7 or higher
- Node.js and npm
- A terminal or command prompt to run commands
### Installation 🛠️
1. Clone the project:
```bash
git clone https://github.com/yourusername/FractureAI.git
cd FractureAI
```
2. Install the necessary Python packages:
```bash
pip install -r requirements.txt
```
3. Start the backend server:
```bash
cd backend/app
python main.py
```
4. Start the frontend:
```bash
cd frontend
npm install
npm start
```
5. Open your browser and go to `http://localhost:5000` to use the app.
## Usage 💡
1. Upload an X-ray image using the upload feature.
2. Click the "Analyze X-ray" button to check the image.
3. View the results, including marked fractures and a detailed report.
## Contributing 🤝
Want to help? Here’s how you can contribute:
1. Fork the project.
2. Create a new branch: `git checkout -b feature/YourFeature`.
3. Make your changes and commit: `git commit -m 'Add some feature'`.
4. Push your branch: `git push origin feature/YourFeature`.
5. Open a pull request.
**Guidelines**:
- Follow the existing code style.
- Write clear commit messages.
- Test your changes before submitting a pull request.
Thank you for contributing!
## 📜 License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
## 📧 Contact
For questions or support, please reach out via the contact methods on my GitHub profile.