TexFusion – AI-Powered Textile Defect Detection, Pattern Recognition & Design Generation

TexFusion is an AI-powered textile automation platform that integrates fabric defect detection, pattern recognition, and GAN-based design generation. It helps textile industries improve quality control while enabling rapid creation of new fabric patterns. The system provides a unified, intelligent workflow combining computer vision and generative AI.

Table of Contents

• About
• What is TexFusion?
• Features
• Why TexFusion?
• Getting Started
• Prerequisites
• Installation
• Backend Setup
• Building the App
• TechStack Used
• System Architecture
• Screenshots and App Demonstration
• Conclusion
• Developed By

About

What is TexFusion?

TexFusion is a comprehensive deep-learning system built to modernize textile manufacturing. It analyzes fabric images for defects using CNNs, identifies pattern categories using EfficientNetB3, and generates new textile designs using a conditional DCGAN model. The platform provides fast, accurate, and creative support for both quality assurance and textile design teams.

Features

• Automated Fabric Defect Detection
  • Detects stains, holes, weave faults, horizontal/vertical line defects using a CNN-based inspection model.
  • Provides confidence scores and top-3 predictions for improved quality assessment.
  • Ensures consistent and reliable defect detection compared to manual inspection.


• Pattern Recognition (19 Textile Categories)
  • EfficientNetB3 architecture trained on 19 fabric pattern classes for high-accuracy classification.
  • Supports recognition of patterns such as floral, stripes, geometric, checks, abstract, and more.
  • Helps designers and manufacturers categorize fabrics for inventory and production workflows.


• AI Design Generation (Conditional DCGAN)
  • Generates new textile patterns conditioned on selected pattern categories.
  • Produces unique, visually coherent, and creative fabric designs using PyTorch-based GAN models.
  • Allows rapid prototyping of designs without manual drawing.


• Color & Style Customization
  • Real-time hue, saturation, and brightness adjustments on generated designs.
  • Applies enhancement filters such as sharpen, smooth, and stylize for aesthetic refinement.
  • Enables quick experimentation with multiple color variations.


• Motif Overlay & Tiling
  • Upload custom motifs (PNG) and overlay them on generated backgrounds.
  • Supports repeating motifs in tiled or centered formats, ideal for fabric print layouts.
  • Creates production-ready textile patterns with both background and motif layers.


• Interactive Web Interface
  • Simple upload-based workflow for inspection, pattern recognition, and design generation.
  • Displays predictions, confidence levels, and design previews in real time.
  • Allows users to download final textile designs instantly.


• Optimized Backend Architecture
  • Flask backend integrating CNN, EfficientNetB3, and DCGAN models through dedicated REST APIs.
  • Seamless communication with the frontend for fast inference and design generation.
  • Robust processing pipeline with image preprocessing, prediction, post-processing, and rendering.

Why TexFusion?

• Improved Fabric Quality Control: Automates defect detection using AI, reducing manual errors and ensuring consistent inspection standards across textile batches.
• Fast & Accurate Pattern Identification: EfficientNetB3-based pattern recognition helps categorize fabrics instantly, supporting designers, manufacturers, and inventory teams.
• AI-Powered Design Innovation: The conditional DCGAN model enables rapid generation of new textile patterns, helping designers explore creative ideas without manual sketching.
• End-to-End Textile Workflow: Combines quality inspection, pattern recognition, and design generation into one unified platform for maximum productivity.
• Customization-Focused Tools: Offers dynamic color tweaking, enhancement filters, and motif overlays, allowing users to create production-ready designs tailored to their needs.
• Fast, Lightweight, and User-Friendly: The web-based interface provides an intuitive workflow with real-time previews, easy image uploads, and instant design downloads.

Getting Started

Prerequisites

Before you begin, ensure that the following software and dependencies are installed in your development environment:

For Backend (Flask + AI Models):

• Python 3.8+: Required for running the TexFusion backend and all deep-learning models.
  • Download Python
• pip: Python package manager used to install project dependencies.
• Required Python Libraries:
  • TensorFlow / Keras (for CNN & EfficientNetB3 models)
  • PyTorch (for Conditional DCGAN)
  • OpenCV (for image processing & color adjustments)
  • NumPy, Pillow, Flask, Flask-CORS
• Pretrained Model Files:
  • CNN model for fabric defect detection
  • EfficientNetB3 pattern recognition model
  • DCGAN generator weights for textile design generation

For Frontend (Web Interface):

• Any modern web browser (Chrome, Edge, Firefox).
• Basic static server (optional): You can simply open index.html directly or use VS Code Live Server.
• Ensure backend API URLs are updated inside your JavaScript files.

Installation

Clone the Repository:

git clone https://github.com/Suhas-Varna/TexFusion.git
cd TexFusion

Backend Setup (Flask)

1. Create Virtual Environment (Recommended):

   python -m venv venv

2. Activate Virtual Environment:

   # Windows
   venv\Scripts\activate
   # Mac / Linux
   source venv/bin/activate

3. Start the Flask Backend Server:

   python app.py

   The backend will run at: http://127.0.0.1:5000/

4. Ensure Model Paths Are Correct:

   Update the paths for: CNN model, EfficientNetB3 model, and DCGAN weights inside app.py.

Frontend Setup

1. Navigate to the frontend directory (if applicable) or simply open the index.html file.

2. Update API Base URL inside your JavaScript:

   const BASE_URL = "http://127.0.0.1:5000";

3. Run the frontend:

   • Option 1: Open index.html directly in browser
   • Option 2: Use VS Code → Live Server

TechStack - Built With

Python: Core programming language used for building the backend and all AI model pipelines (CNN, EfficientNetB3, DCGAN).

Flask: Lightweight web framework used to serve the three TexFusion APIs — defect detection, pattern recognition, and design generation.

TensorFlow/Keras: Used for training and deploying the CNN defect detection model and EfficientNetB3 pattern recognition classifier.

PyTorch: Framework used to build and run the Conditional DCGAN responsible for textile design generation.

OpenCV: Handles image preprocessing, HSV color adjustments, enhancement filters, and motif overlay operations.

HTML, CSS, JavaScript: Used to create a simple yet interactive web interface that allows users to upload images, preview outputs, and download generated designs.

System Architecture

🏗️ High-Level Architecture

┌─────────────────────────────────────────────────────────────────────────────┐
│                                TexFusion APP                                │
│   ┌───────────────────┐   ┌─────────────────────┐   ┌────────────────────┐  │
│   │   Home Screen     │ → │ Image Upload Module │ → │  API Request Layer │  │
│   └───────────────────┘   └─────────────────────┘   └────────────────────┘  │
│                ↓                       ↓                       ↓            │
│      ┌───────────────────┐   ┌───────────────────┐   ┌───────────────────┐  │
│      │ Defect Detection  │   │ Pattern Classifier│   │ Design Generator  │  │
│      │      (CNN)        │   │ (EfficientNetB3)  │   │  (DCGAN Model)    │  │
│      └───────────────────┘   └───────────────────┘   └───────────────────┘  │
│                ↓                       ↓                       ↓            │
│     ┌────────────────────┐   ┌────────────────────┐   ┌──────────────────┐  │
│     │ JSON Predictions   │   │ Pattern Labels     │   │ Generated Images │  │
│     └────────────────────┘   └────────────────────┘   └──────────────────┘  │
└──────────────────────────────────────│──────────────────────────────────────┘
                                       │ API CALLS / JSON RESPONSE
                                       ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                               FASTAPI BACKEND                               │
│   ┌──────────────────────────────────────────────────────────────────────┐  │
│   │          Request Router & Processing Engine                          │  │
│   │  • Routes user-uploaded images to correct model                      │  │
│   │  • Handles CNN, EfficientNet, and GAN inference                      │  │
│   │  • Returns predictions or generated designs                          │  │
│   └──────────────────────────────────────────────────────────────────────┘  │
│     │                       │                           │                   │
│     ▼                       ▼                           ▼                   │
│  /detect-defect       /classify-pattern             /generate-design        │
└─────────────────────────────────────────────────────────────────────────────┘

📊 Data Flow Diagram

  USER UPLOADS FABRIC IMAGE
                │
                ▼
┌─────────────────────────────────────────────────────┐
│                TexFusion Frontend                   │
│  • Uploads image                                    │
│  • Selects feature: Defect / Pattern / Design       │
└───────────────────┬─────────────────────────────────┘
                    │  HTTP POST (multipart image)
                    ▼
┌─────────────────────────────────────────────────────┐
│                 FastAPI Backend                     │
│  • Accepts image                                    │
│  • Validates and preprocesses                       │
│  • Forwards to respective ML module                 │
└───────────────────┬─────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────────┐
│                 MODEL PROCESSING                    │
│  • CNN → Detects six defect classes                 │
│  • EfficientNetB3 → Predicts 19 textile patterns    │
│  • Conditional DCGAN → Generates new designs        │
└───────────────────┬─────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────────┐
│                 JSON Response / Image Output        │
│  • Predicted class + confidence                     │
│  • Suggested pattern group                          │
│  • Generated textile design image                   │
└───────────────────┬─────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────────────────┐
│                 TexFusion Frontend                  │
│  • Displays results                                 │
│  • Allows color edits & motif overlays (GAN)        │
│  • Supports download of final design                │
└─────────────────────────────────────────────────────┘

🗂️ Project Structure

TexFusion/
│
├── frontend/                       # Web UI (HTML, CSS, JS)
│   ├── index.html
│   ├── upload.css
│   ├── design.js
│
├── backend/                        # FastAPI Server
│   ├── main.py                     # API endpoints
│   ├── defect_model/               # CNN model files
│   ├── pattern_model/              # EfficientNetB3 model files
│   ├── gan_model/                  # DCGAN generator + embeddings
│   ├── utils/                      # Preprocessing, helpers
│   └── requirements.txt
│
└── README.md

Note: Due to large file sizes, the trained model files are excluded from this repository. Please contact us via email to obtain access to the models.

🔐 TexFusion Security Architecture

• Secure Model Access:
  • All ML models run locally on the server
  • No external API dependency
  • No cloud upload of user data
• Data Privacy:
  • Uploaded images processed in-memory only
  • No images or metadata stored on server
  • Automatic cleanup of temp files
• API Security:
  • CORS restricted to trusted UI origins
  • Validation on image size, format, and request type
  • Rate-limiting for design generation requests

⚡ TexFusion Performance Optimizations

• Backend Optimizations:
  • Efficient batch preprocessing
  • Model warm-loading for faster inference
  • GPU-accelerated GAN generation (optional)
• Frontend Optimizations:
  • Lazy-loaded image previews
  • Client-side color filters using Canvas API
  • Compressed API responses for faster rendering

App Demonstration

Screenshots

Conclusion

TexFusion successfully integrates defect detection, pattern recognition, and AI-driven design generation into a unified textile intelligence platform. By combining CNNs, EfficientNetB3, and a Conditional DCGAN, the system automates critical manufacturing and creative processes with high reliability. Its interactive web interface enables real-time inspection and customizable design generation, reducing manual effort and streamlining workflows. Overall, TexFusion demonstrates how AI can enhance productivity, accuracy, and innovation in the textile industry.

The Team

Suhas Varna

Seeripi Ganesh Kumar

Vikas D H

Sanjay J