.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
GUI Iterface using Python and Tkinter
GUI Interface is a desktop-based application developed using Python and Tkinter that provides an integrated graphical environment for user management, scientific application control, C program execution, and execution monitoring.
The project was designed to simplify the workflow of compiling and executing FFTW-based C programs through an intuitive graphical interface while eliminating the need for direct command-line interaction. It combines authentication, administration, execution management, logging, and scientific GUI design into a single platform.
The application serves as a bridge between high-level user interaction and low-level scientific program execution, allowing users to work with computational applications in a structured and user-friendly environment.
The primary objective of this project is to provide a centralized graphical environment that simplifies the execution and management of scientific C programs.
Key goals include:
- Reducing dependency on command-line operations.
- Providing a secure user authentication system.
- Simplifying execution of GCC-based C programs.
- Integrating FFTW-enabled scientific applications.
- Tracking execution history and system activities.
- Providing administrative control over users and permissions.
- Creating a foundation for future scientific image-processing applications.
The project also demonstrates how Python can be used as a wrapper layer to coordinate multiple software components including graphical interfaces, compilers, external libraries, and execution environments.
The application follows a layered architecture model.
The Presentation Layer is developed using Tkinter and provides:
- Login Window
- Registration Window
- Welcome Dashboard
- Admin Dashboard
- ESP Execution Interface
- History Viewer
- Statistics Dashboard
- Scientific Data Analysis Interface
This layer handles all user interactions.
The Application Logic Layer controls:
- User authentication
- Password verification
- Command processing
- Role validation
- History management
- System logging
- Error handling
This layer acts as the core controller of the application.
The Execution Layer is responsible for:
- Validating execution commands
- Generating compiler instructions
- Running GCC compilation processes
- Launching executable files
- Capturing program output
Python's subprocess module is used to communicate with external programs.
The Scientific Processing Layer supports:
- FFTW library integration
- Scientific computation workflows
- Fourier Transform-based applications
- Future image-processing extensions
This layer provides computational capabilities for scientific applications.
The Monitoring Layer records:
- User activities
- Execution history
- Administrative actions
- Runtime information
- System events
All records are maintained using JSON-based storage.
The application includes a complete authentication framework featuring:
- User Registration
- User Login
- SHA-256 Password Hashing
- Failed Login Protection
- Account Blocking Support
- Role-Based Access Control
Passwords are never stored in plain text and are encrypted before storage.
A dedicated administrative interface allows system management operations such as:
- Viewing Registered Users
- Blocking Users
- Unblocking Users
- Promoting Assistant Administrators
- Removing Administrative Privileges
- Monitoring User Activity
All administrative operations are logged automatically.
The Easy Prompt System provides a command-driven execution environment inside the GUI.
Users can execute programs using commands such as:
run code1.c
The system automatically:
- Validates the command.
- Compiles the source file.
- Links FFTW libraries.
- Executes the program.
- Displays the output.
This significantly reduces the complexity of executing scientific applications.
The project includes a built-in troubleshooting framework capable of analyzing:
- Login Errors
- Validation Errors
- Compilation Errors
- Runtime Errors
The system provides guidance and recommendations to assist users in identifying problems and correcting mistakes.
A code explanation module generates simple line-by-line descriptions of source code.
This functionality helps beginners understand:
- Program structure
- Loops
- Functions
- Memory operations
- FFTW function calls
The feature transforms the application into both a development and learning environment.
Every program execution is recorded automatically.
Stored information includes:
- Username
- Executed File
- Execution Date
- Execution Time
This provides accountability and historical tracking of system usage.
The Statistics Dashboard provides execution analytics including:
- Total Executions
- Most Active User
- Most Frequently Executed Program
- User Execution Counts
- File Execution Counts
These statistics provide useful operational insights.
The project contains a dedicated scientific interface designed to support future image-processing workflows.
The interface currently includes:
- Load Target
- Load Calibration Data
- Status Indicators
- Pixel Size
- Resolution
- Wavelength
- Diameter
- Segment Size
- Processing Modes
- Reconstruction Options
- Scientific Configuration Parameters
- Black Canvas Display Area
- Plot Controls
- Threshold Controls
- Display Configuration Tools
The design follows the layout commonly used in research and laboratory software systems.
| Technology | Purpose |
|---|---|
| Python | Core Application Development |
| Tkinter | Graphical User Interface |
| JSON | Data Storage |
| hashlib (SHA-256) | Password Security |
| subprocess | External Process Management |
| GCC (MinGW) | C Compilation |
| FFTW | Scientific Computation |
| Pillow (PIL) | Image Handling |
GUI-Interface-Python-Tkinter
│
├── main.py
├── users.json
├── history.json
├── system_log.json
├── admin_notifications.json
├── README.md
│
└── Additional C Source Files
- Python 3.x
- GCC Compiler (MinGW-w64)
- FFTW Library
pip install pillowpython main.pySeveral improvements can be implemented to further extend the project:
- Migration from Tkinter to PyQt/PySide
- Scientific Image Reconstruction Pipeline
- OpenCV Integration
- NumPy and SciPy Support
- FITS File Handling
- Real-Time Plotting
- Multi-Threaded Processing
- Progress Monitoring Dashboard
- Advanced Data Visualization Tools
- Modular Software Architecture
This project demonstrates practical implementation of:
- GUI Development
- User Authentication Systems
- Role-Based Access Control
- Compiler Integration
- External Process Management
- Scientific Computing Workflows
- Logging and Monitoring Systems
- Software Architecture Design
- Python and C Interoperability
Aparajith M G
Internship Project
Indian Institute of Astrophysics (IIA), Bangalore
This project is intended for educational, research, and demonstration purposes.