Skip to content

RADson2005official/RDCconPROJ

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

11 Commits
.idea
.idea
 
 
.lh
.lh
 
 
App
App
 
 
README.md
README.md
 
 
requirements.txt
requirements.txt
 
 
run.py
run.py
 
 
yolov8n.pt
yolov8n.pt
 
 

Repository files navigation

RDC Concrete Aggregate Measurement System

📋 Table of Contents

Project Overview

🎯 What Does This Project Do?

The RDC Concrete Aggregate Measurement System is an automated computer vision solution that uses Machine Learning (ML) and Image Processing techniques to accurately measure sand and gravel piles at construction yards. Instead of manual measurements that are time-consuming and error-prone, this system uses cameras and AI to provide precise, real-time measurements.

🚩 Why Was This Created?

Traditional aggregate measurement methods face several challenges:

  • Manual Labor: Requires workers to physically measure piles
  • Time-Consuming: Takes hours to measure large quantities
  • Human Error: Inconsistent measurements between different operators
  • Safety Concerns: Workers need to climb on potentially unstable piles
  • Cost: Expensive labor costs for routine measurements

🎯 Project Goals

  1. Automate Measurement Process: Use AI to eliminate manual measurement
  2. Improve Accuracy: Achieve consistent, precise measurements
  3. Enhance Safety: Remove need for workers to access dangerous areas
  4. Real-time Analytics: Provide instant reports and data visualization
  5. Cost Reduction: Minimize labor costs and operational expenses

🎯 Key Features

🤖 AI-Powered Detection

  • Edge Detection: Automatically identifies pile boundaries using advanced algorithms
  • Material Classification: Distinguishes between sand, gravel, and other materials
  • Corner Detection: Precisely locates pile corners for accurate volume calculation

🖼️ Advanced Image Processing

  • Dual-View Analysis: Processes both top and front view images
  • Noise Reduction: Removes image artifacts for cleaner analysis
  • Enhanced Edge Detection: Combines traditional and deep learning methods
  • Adaptive Thresholding: Handles varying lighting conditions

📊 Smart Analytics

  • Volume Calculation: Computes pile volume using 3D reconstruction
  • Real-time Processing: Instant results with live camera feeds
  • Data Visualization: Interactive charts and 3D representations
  • Export Capabilities: Generate reports in multiple formats

🧠 Machine Learning & Computer Vision Concepts

This section explains the technical concepts in beginner-friendly terms

🔍 Computer Vision Basics

What is Computer Vision? Computer Vision is like giving computers the ability to "see" and understand images, just like humans do. In our project, we teach the computer to recognize sand piles, measure their size, and distinguish different materials.

Key Techniques Used:

  1. Edge Detection 🎯

    • What it does: Finds the outline/boundaries of objects in images
    • How it works: Looks for sudden changes in color or brightness
    • In our project: Identifies pile edges to calculate volume
    • Algorithm used: Canny Edge Detection + Deep Learning models

  2. Image Segmentation 🧩

    • What it does: Separates different parts of an image
    • How it works: Groups similar pixels together
    • In our project: Separates pile from background and ground

  3. Feature Detection 🎯

    • What it does: Finds important points and shapes in images
    • How it works: Identifies corners, lines, and patterns
    • In our project: Locates pile corners for 3D reconstruction

🤖 Machine Learning Components

Deep Learning Models:

  1. Vision Transformer (ViT) 🔮

    • Purpose: Material classification (sand vs. gravel)
    • How it works: Analyzes image patterns to classify materials
    • Benefits: More accurate than traditional methods

  2. Convolutional Neural Networks (CNNs) 🧠

    • Purpose: Enhanced edge detection
    • How it works: Uses multiple layers to detect complex patterns
    • Benefits: Better performance in challenging lighting conditions

Traditional Computer Vision:

  • Gaussian Blur: Smooths images to reduce noise
  • Adaptive Thresholding: Converts images to black/white for better analysis
  • Morphological Operations: Cleans up detected edges

🛠 Technologies Used

Programming Languages

  • Python (69.8%) 🐍 - Main backend logic and AI processing
  • HTML (12.6%) 🌐 - Web interface structure
  • JavaScript (12.3%) ⚡ - Interactive frontend features
  • CSS (5.3%) 🎨 - User interface styling

Machine Learning & Computer Vision Libraries

  • OpenCV - Image processing and computer vision operations
  • PyTorch - Deep learning framework for AI models
  • Transformers - Pre-trained models for material classification
  • NumPy - Numerical computations for image arrays
  • PIL/Pillow - Image loading and basic processing

Web Framework

  • Flask - Python web framework for the user interface
  • HTML/CSS/JavaScript - Frontend technologies

Additional Tools

  • CUDA - GPU acceleration for faster AI processing
  • Matplotlib - Data visualization and plotting
  • Logging - System monitoring and debugging

📦 Installation

Prerequisites

Before installation, ensure you have:

  • Python 3.8+ installed
  • Git for repository cloning
  • CUDA-compatible GPU (optional, for faster processing)
  • Webcam or IP camera for live image capture

Step-by-Step Installation

  1. Clone the Repository

    git clone https://github.com/RADson2005official/RDCconPROJ.git
cd RDCconPROJ

  2. Create Virtual Environment (Recommended)

    # Windows
python -m venv venv
venv\Scripts\activate

# macOS/Linux
python3 -m venv venv
source venv/bin/activate

  3. Install Dependencies

    pip install -r requirements.txt

  4. Install Additional Computer Vision Dependencies

    # For OpenCV with additional features
pip install opencv-contrib-python

# For GPU acceleration (if CUDA available)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

  5. Verify Installation

    python -c "import cv2, torch; print('OpenCV:', cv2.__version__); print('PyTorch:', torch.__version__)"

🚀 Usage

Starting the Application

  1. Launch the Web Server

    python app.py

  2. Access the Interface

    • Open your browser
    • Navigate to http://localhost:5000

Basic Workflow

  1. Upload Images 📸

    • Click "Upload Image" or use camera capture
    • Provide both top-view and front-view images for best results

  2. Configure Settings ⚙️

    • Select measurement units (cubic meters/feet)
    • Choose processing method (Traditional CV or AI-Enhanced)
    • Set material type (Sand/Gravel/Auto-detect)

  3. Process Images 🔄

    • Click "Analyze Images"
    • System will automatically:
      • Detect pile edges
      • Classify material type
      • Calculate volume
      • Generate visualization

  4. View Results 📊

    • Volume measurements
    • 3D visualization
    • Material classification confidence
    • Processing statistics

  5. Export Data 💾

    • Download measurement reports
    • Save processed images
    • Export data in CSV/JSON format

Advanced Features

AI Model Configuration:

# Enable deep learning models
processor = ImageProcessor()
processor.use_dl = True  # Enable AI-enhanced processing

Custom Edge Detection:

# Adjust edge detection sensitivity
edges = processor.detect_pile_edges(
    image, 
    low_threshold=50,  # Lower = more sensitive
    high_threshold=150  # Higher = less noise
)

📁 Project Structure

RDCconPROJ/
├── App/
│   ├── Utils/
│   │   ├── ImageProcessor.py     # Main AI/CV processing
│   │   ├── EdgeDetection.py      # Edge detection algorithms
│   │   ├── Visualizer.py         # Data visualization
│   │   └── VolumeCalculator.py   # 3D volume computation
│   ├── static/                   # CSS, JS, images
│   ├── templates/                # HTML templates
│   └── routes.py                 # Web application routes
├── models/                       # Pre-trained AI models
├── data/                         # Sample images and datasets
├── tests/                        # Unit tests
├── docs/                         # Documentation
├── requirements.txt              # Python dependencies
├── app.py                        # Main application entry
└── README.md                     # This file

Key Files Explained:

  • ImageProcessor.py: Core AI engine containing all computer vision algorithms
  • EdgeDetection.py: Specialized edge detection implementations
  • VolumeCalculator.py: 3D reconstruction and volume calculation
  • Visualizer.py: Creates charts, graphs, and 3D visualizations
  • app.py: Web server that ties everything together

🔧 Configuration

System Settings

Create a config.py file to customize behavior:

# Computer Vision Settings
EDGE_DETECTION_METHOD = "hybrid"  # "traditional", "deep_learning", "hybrid"
USE_GPU_ACCELERATION = True       # Enable CUDA if available
IMAGE_RESIZE_DIMENSION = 800      # Max image dimension for processing

# AI Model Settings
MATERIAL_CLASSIFICATION_CONFIDENCE = 0.7  # Minimum confidence threshold
ENABLE_MATERIAL_CLASSIFICATION = True     # Auto-detect material type

# Measurement Settings
DEFAULT_UNITS = "cubic_meters"    # "cubic_meters", "cubic_feet"
CALIBRATION_FACTOR = 1.0          # Adjust for camera calibration

# Performance Settings
MAX_PROCESSING_TIME = 30          # Seconds before timeout
ENABLE_CACHING = True             # Cache processed results

Camera Calibration

For accurate measurements, calibrate your camera:

  1. Capture Calibration Images

    • Take photos of known objects (like a standard cube)
    • Include in different positions and angles

  2. Run Calibration Script

    python calibrate_camera.py --images calibration_folder/

  3. Update Configuration

    • System will automatically update calibration factors

🤝 Contributing

We welcome contributions from developers of all skill levels! Here's how to contribute:

Getting Started

  1. Fork the Repository

    • Click "Fork" on GitHub
    • Clone your fork locally

  2. Set Up Development Environment

    git clone https://github.com/YOUR_USERNAME/RDCconPROJ.git
cd RDCconPROJ
pip install -r requirements-dev.txt  # Development dependencies

  3. Create Feature Branch

    git checkout -b feature/your-feature-name

Contribution Areas

For ML/AI Enthusiasts:

  • Improve edge detection algorithms
  • Add new material classification models
  • Enhance 3D reconstruction accuracy
  • Optimize model performance

For Web Developers:

  • Improve user interface design
  • Add new visualization features
  • Enhance mobile responsiveness
  • Implement real-time updates

For Beginners:

  • Update documentation
  • Add unit tests
  • Fix bugs in issue tracker
  • Improve code comments

Submission Process

  1. Make Your Changes

    • Follow coding standards
    • Add comments explaining complex logic
    • Update tests if necessary

  2. Test Your Changes

    python -m pytest tests/
python -m flake8 App/  # Check code style

  3. Submit Pull Request

    • Write clear description of changes
    • Reference any related issues
    • Include screenshots for UI changes

Code Style Guidelines

  • Follow PEP 8 for Python code
  • Use descriptive variable names
  • Comment complex algorithms
  • Include docstrings for functions
  • Keep functions focused and small

❓ FAQ

General Questions

Q: Do I need a powerful computer to run this? A: The system works on most modern computers. GPU acceleration helps but isn't required. Processing time may be longer on older hardware.

Q: What image formats are supported? A: Common formats including JPG, PNG, BMP, and TIFF are supported.

Q: Can I use this for materials other than sand and gravel? A: Yes! The material classification can be retrained for other granular materials like rice, beans, or industrial pellets.

Technical Questions

Q: How accurate are the volume measurements? A: With proper calibration, accuracy is typically within 2-5% of actual volume. Accuracy improves with better camera positioning and lighting.

Q: Can I integrate this with existing systems? A: Yes! The system provides REST APIs for integration with inventory management or ERP systems.

Q: Does this work with live camera feeds? A: Yes! The system supports real-time processing from webcams or IP cameras.

Machine Learning Questions

Q: How do I improve material classification accuracy? A: You can retrain the model with more images of your specific materials. See the training documentation in /docs/model_training.md.

Q: Can I add new detection algorithms? A: Absolutely! The modular design allows easy integration of new computer vision algorithms.

🐛 Troubleshooting

Common Issues

Issue: "CUDA out of memory" error

# Solution: Reduce image size or disable GPU
export CUDA_VISIBLE_DEVICES=""  # Disable GPU
# Or edit config.py: USE_GPU_ACCELERATION = False

Issue: Poor edge detection results

# Solution: Adjust detection parameters
processor = ImageProcessor()
# For lighter materials (sand):
edges = processor.detect_pile_edges(image, low_threshold=30, high_threshold=100)
# For darker materials (gravel):
edges = processor.detect_pile_edges(image, low_threshold=50, high_threshold=150)

Issue: Material classification always returns "Unknown"

# Solution: Check model files
python -c "import torch; print('CUDA available:', torch.cuda.is_available())"
# Reinstall models if needed:
python download_models.py

Issue: Web interface not loading

# Check if port is available
netstat -an | grep :5000
# Try different port
python app.py --port 8080

Performance Optimization

For Faster Processing:

  1. Resize Images: Reduce image size before processing
  2. Use GPU: Enable CUDA acceleration if available
  3. Optimize Settings: Reduce edge detection iterations
  4. Batch Processing: Process multiple images together

For Better Accuracy:

  1. Improve Lighting: Ensure consistent, bright lighting
  2. Camera Position: Position camera directly above pile center
  3. Background: Use contrasting background colors
  4. Calibration: Regular camera calibration improves accuracy

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

What This Means:

  • ✅ Modification: You can modify the code
  • ✅ Distribution: You can share the software
  • ✅ Private Use: You can use it privately
  • ❗ Limitation: No warranty or liability
  • ❗ License Notice: Must include original license

🙏 Acknowledgements

Open Source Libraries

  • OpenCV Community - Computer vision algorithms
  • PyTorch Team - Deep learning framework
  • Hugging Face - Pre-trained transformer models
  • Flask Community - Web framework

Research References

  • Canny, J. (1986). "A Computational Approach to Edge Detection"
  • Dosovitskiy, A. et al. (2020). "An Image is Worth 16x16 Words: Transformers for Image Recognition"
  • Traditional computer vision techniques from multiple academic sources

Special Thanks

  • RDC Concrete (India) Limited - Project sponsorship and real-world testing
  • Computer Vision Community - Algorithms and best practices
  • Contributors - All developers who have contributed to this project

📞 Contact Information

Project Maintainer

Support Channels

Community

  • Discussions: Join our GitHub Discussions for technical questions
  • Contributions: See Contributing Guidelines above

🚀 What's Next?

Upcoming Features

  • Cloud Integration: AWS/Azure deployment options
  • Advanced Analytics: Machine learning insights and predictions
  • Multi-Camera Support: Stereo vision for improved accuracy

Learning Resources

  • Computer Vision Course: Links to recommended online courses
  • PyTorch Tutorials: Deep learning fundamentals
  • OpenCV Documentation: Comprehensive CV library guide
  • Project Blog: Technical articles and tutorials

Last Updated: July 2025 Version: 2.0.0

Ready to get started? 🚀 Jump to Installation or View Quick Start Guide

About

The RDC Concrete Aggregate Measurement System project aims to develop an automated solution for accurately measuring sand and gravel piles at RDC Concrete (India) Limited yards

Resources

Readme
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages