Software Requirement Specification (SRS) Document

22BCE0754
JAYA VARDHAN

LA-1

Scenario:
In detecting edges using image processing system license plate edge is detected. An
image processing and computer vision methodology is used to detect edge of the license plate. Image
preprocessing steps are used for accurate result. Image enhancement, recognition, restoration and
compression steps are used in this project to detect edge of the license plate. Before image
preprocessing steps, RGB image is converted to gray scale image and image is resized keeping aspect
ratio same. Morphological processing is used which helps to detect text more accurately. Image is
converted to double. Edge detection method is used to detect edges and image intensity level is
increased. Objects which have gaps are filled. After Edge detection, image might contain many
horizontal and vertical lines. These lines should be removed from image which helps to extract only
text from image. After applying these image preprocessing steps, image is left with few smaller
unwanted objects. These unwanted objects are removed. After applying image preprocessing steps,
edge detection function is applied on processed image. The edges of image are considered to be the
most important attributes of image that provide valuable information for human image perception.
As the data of edge detection is very large, therefore the speed of image processing becomes a
difficult problem. Finally detected edge of the name plate is displayed.

1st Aim:
To assign a process model,a process model (also called a software development lifecycle or
SDLC) is a representation of a software development process. It defines the sequence of stages or
activities involved in creating and maintaining software.

We choose Spiral Model

Factors to consider for Choosing the process model

Complexity and project size

The Complex project with interdependencies may require iterative models
(Spiral and Agile Model) to manage risks and accommodate changes effectively.

Requirements
Requirements are expected to change frequently based on user feedback or
market conditions.

Customer Involvement
Customer Involvement is for feedbacks and any risk management issues while
detecting license plates and speed,complexity while coming to time(As Customer Involvement is
minimal)

Risk management
Project has high risks related to technology, performance, or user
requirements,which is crucial for addressing uncertainties in image processing algorithms.

The Spiral model combines iterative development with risk assessment, making it suitable for projects
with significant complexity and uncertainty. It emphasizes continuous refinement and risk
management.
Why we choose the Spiral Model:

Stages:
The project can be split into multiple stages, with each stage involving planning
, risk assessment, engineering, and review.

Risk Evaluation
At the conclusion of each spiral, evaluate risks associated with image
processing methods, including the efficiency of edge detection approaches and
the influence of preprocessing stages on performance.

Prototyping
Creating prototpes for various image processing methods (Algorithms) and
assess their efficency in Identifying License plates in the images. In consideration of
risk management (time and errors)

User Feedback:
Taking feedbacks from users after end of each phase to improve the
method and implement required changes

Why not other process Models

1. Waterfall Model:

The Waterfall Model is a linear and sequential approach where each phase must
be completed before moving to the next. It does not accommodate changes easily. If requirements
evolve or if the initial edge detection methods do not yield satisfactory results, going back to a
previous phase cannot be done(Money loss).

2. V Model

The V-Model emphasizes verification and validation at each development stage, with a
corresponding testing phase for each development phase.Similar to the Waterfall Model, it is not
well-suited for projects with evolving requirements. Changes in the image processing techniques or
algorithms would require revisiting multiple phases.

3. Incremental Model

The Incremental Model involves developing the software in small, manageable

increments, allowing for partial deployment and feedback.As increments are developed, integrating
them into a cohesive system can be challenging, especially if the requirements change or if different
techniques yield varying results.

4. Agile Model

The Agile Model emphasizes iterative development, collaboration, and flexibility,

allowing for adjustments based on user feedback.While Agile is flexible, it may not emphasize risk
assessment as strongly as the Spiral Model. For a project involving complex image processing,
understanding and mitigating risks is crucial.

The overall Process Structure is

1. Image Acquisition
Capture the license plate image using a camera, ensuring optimal lighting conditions to reduce
noise and enhance clarity

2. Image Preprocessing
Color Space Conversion: Transform the RGB image into a grayscale format. This simplification
reduces data complexity, as edge detection algorithms generally function more effectively on
single-channel images.
Resizing: Adjust the image size while preserving the aspect ratio to maintain the integrity of the
license plate features, making it suitable for further processing.

3. Image Enhancement Histogram Equalization:

This technique can be utilized to enhance the contrast of the grayscale image, thereby making
the edges more pronounced. Noise Reduction: Implement filters, such as Gaussian blur, to diminish
noise that may disrupt edge detection.

4. Morphological Processing
Employ morphological operations, such as dilation and erosion, to refine the text structure on
the license plate. This process aids in connecting fragmented text and eliminating minor noise.

5. Edge Detection
Convert the image to a double format to facilitate edge detection algorithms. Utilize an edge
detection technique, such as Canny, Sobel, or Prewitt, to pinpoint the edges within the image. The
Canny edge detector is particularly favored for its proficiency in identifying a broad spectrum of
edges.

6. Post-Processing Line Removal:

Following edge detection, the image may exhibit numerous horizontal and vertical lines that
do not pertain to the license plate text. These can be eliminated using methods like Hough Transform
or morphological operations. Object Removal: Detect and eliminate smaller, irrelevant objects that do
not relate to the license plate text, employing contour detection or connected component analysis.

7. Final Edge Detection

After completing all preprocessing steps, reapply the edge detection function to the refined
image. This should result in a clearer depiction of the license plate edges.

What I observed in the scenario

Next is Like finding the requirements

Functional Aspect and Non Functional Aspect

First Functional Requirements

1. Image Acquisation
2. Image Pre-processing
3. Edge detection
4. Text Analysis
5. Post Processing work(storing)
6. Results Analysis
7. Integrate software and Hardware
8. Complete Testing Phase
9. Analysis of Real time

Non Functional Requirements

performance: The system must be capable of processing images within a designated
timeframe, such as under 2 seconds for applications requiring real-time responses.

scalability: The system should support the simultaneous upload of multiple images
without any decline in performance.

usability: The user interface ought to be user-friendly and straightforward,

accommodating individuals with different levels of technical knowledge.

reliability: The system should reliably deliver precise edge detection outcomes across
diverse license plate designs and environmental conditions.

Work Break Down structure

A Work Breakdown Structure (WBS) is a hierarchical decomposition of a project into smaller, more
manageable components. It helps in organizing the team's work into manageable sections, making it
easier to plan, execute, and monitor the project. The WBS is typically represented in a tree structure
or a list format.
UML Diagrams

Unified Modeling Language (UML) diagrams are essential tools in software engineering and system
design. They provide a standardized way to visualize the design of a system, making it easier for
stakeholders to understand and communicate about the system's architecture and behavior.

USE CASE Diagram

The use cases that I find are

Enhanced Diagram

**User**(Actor): Denotes the individual engaging with the system.(Vehicle)

Take Picture: The user begins the process by taking a picture.

Examine Processed Image: The user is able to see the image once it has been processed.
Store Finalized Image: The user is able to save the ultimate processed image.(If the traffic rules are
Prepare Image: The obtained image is processed initially to ready it for additional examination.
Employ Edge Detection: An edge detection technique is utilized to emphasize the edges within the
image.
Post Processing: Extra steps are taken to enhance the image.
This diagram clearly illustrates the workflow of the image processing system
and how users engage with it

State Flow Diagram

The starting condition of the procedure.

Capture Image: The system enters this state when the process of capturing an image starts.

Image Preprocessing: The acquired image undergoes preprocessing to ready it for additional analysis.

Utilize Edge Detection: The edge detection algorithm is utilized on the preprocessed image.

Post Processing: Extra steps are taken to enhance the image.

Show Processed Image: The user is shown the processed image.

Store Processed Image: The user stores the completed processed image.

Conclusion: The ultimate condition signifying the fulfillment of the procedure

This state diagram effectively represents the sequential flow of states in the image processing system.
Sequence flow diagram

Enhanced Diagram

User (Performer)

The individual or external system that triggers the image capture.

Engages solely with the primary system to initiate and obtain the final outcome.

Image Processing System (IPS)

The main controller or conductor.

Accepts image input from the user and oversees the processing pipeline.

Manages the progression between preprocessing, edge detection, post-processing, and visualization.

Data Preparation (DP)

Manages preliminary image alterations:

Grayscale Conversion: Transforms the image into gray tones, streamlining processing.

Resizing: Modifies image size for uniformity and efficiency.

Edge Detection (ED)

Concentrates on identifying borders or outlines in the picture.
Employs algorithms such as Canny, Sobel, and others to identify abrupt variations in brightness.
Post-Production (PostP)
Enhances the image after edge detection:
Noise Elimination: Eliminates undesirable distortions or blemishes.
Edge Enhancement: Clarifies and sharpens the significant lines

Class Diagram

Rough Sketch
Orientation of what I done in drawing the Class diagram

1. ImageProcessingSystem
Role: Acts as the main controller or entry point to the system.

Method:

+detectEdge(): Initiates the edge detection process.

Interaction: Calls upon the preprocessing class to begin image transformations.

2. ImagePreprocessing
Role: Handles the transformation of raw input images to a format suitable for edge detection.

Methods:

+convertToGrayScale() – Converts color image to grayscale.

+resizeImage() – Resizes image dimensions.

+applyMorphologicalProcessing() – Applies filters like erosion/dilation.

+convertToDouble() – Converts image data to floating-point format.

+increaseIntensity() – Enhances image brightness/contrast.

+fillGaps() – Fills small gaps in objects or edges.

+removeUnwantedObjects() – Eliminates noise or irrelevant parts.

Interaction: After preprocessing, it forwards the output to the edge detection module.

3. EdgeDetection
Role: Analyzes the image to find meaningful boundaries or shapes.

Methods:

+detectEdges() – Runs edge detection algorithms (e.g., Sobel, Canny).

+removeLines() – Optional cleaning step to eliminate straight-line artifacts.

+extractText() – (Optional) OCR-style step to read any text in the image.

Interaction: Passes results to the display system for user viewing.

4. DisplaySystem
Role: Handles output visualization.

Method:

+showDetectedEdges() – Renders final result to the screen or UI component.

UML activity diagram

Input Image Preparation

The system starts with a RGB image of a vehicle containing a license plate.

Conversion to Grayscale: Simplifies the image by removing color and reducing data complexity.

Resizing with Aspect Ratio Preserved: Ensures consistent image dimensions while maintaining
proportions.

2. Image Preprocessing (Cleaning & Enhancing)

This is a crucial step to ensure the edge detection algorithm works effectively.

Morphological Processing:

Techniques like dilation, erosion, closing are used to improve text and structure visibility.

Especially useful in preparing license plate characters for recognition.

Conversion to Double:

Converts image pixel values into floating point format (usually [0,1]) for more precise operations.

Increase Intensity:

Enhances contrast and brightness, making edges more distinguishable.

Fill Gaps:

Connects broken or discontinuous parts in objects or characters.

3. Edge Detection
After preprocessing, an edge detection algorithm (e.g., Canny, Sobel) is applied.

Detects boundaries where there are significant changes in pixel intensity.

Outputs a binary image highlighting the edges.

4. Post-Edge Processing
After detecting edges, the image may contain noise and irrelevant information:

Remove Horizontal and Vertical Lines:

These are often parts of the vehicle body or frame—not part of the license plate text.

Removing them helps isolate the actual characters of the plate.

Remove Unwanted Small Objects:

Tiny blobs or dots remaining after edge detection are eliminated.

Focuses only on significant features (like characters).

5. Final Output
The cleaned, edge-detected image is passed to the Display System.

Detected edges of the license plate are shown to the user.

These edges contain critical data, and they form the base for future tasks like character segmentation
and recognition (OCR).

UML Data Flow diagram

Level-0 (abstraction mobel)

Level 1

Level-2

Rough Diagrams
Level -2
Flow Representation

Input Image (Raw RGB)

The process starts when a user uploads an image of a vehicle.

This input image, in RGB format, is sent into the preprocessing pipeline.

2. Convert to Grayscale
Why? Reduces the complexity of the image by removing color.

Converts it into a single-channel grayscale image which contains only intensity information.

Easier to process and ideal for edge detection.

3. Resize Image (Preserve Aspect Ratio)

Why? Standardizes the size of the image for consistent processing.

The aspect ratio is maintained to avoid distortion of license plate characters.

4. Morphological Processing
Why? Enhances structural elements (like text and shapes).

Uses operations like dilation, erosion, opening, and closing.

Helps strengthen lines, edges, and character shapes—useful for detecting plates accurately.

5. Convert to Double
Why? Converts pixel values from integer format to floating-point (double precision).

Allows more accurate mathematical processing in the next steps (especially for intensity and filtering).

6. Increase Intensity
Why? Brightens dark areas and enhances contrast.

Helps improve visibility of edges and characters, making them easier to detect.

7. Fill Gaps
Why? Connects broken parts in objects—especially useful when characters or shapes are incomplete.

Ensures continuity in text or boundary lines before edge detection.

8. Remove Unwanted Objects

Why? Filters out small, irrelevant blobs or noise that are not part of the license plate.

Ensures only important objects (like the plate and characters) are retained.

Final Output: Preprocessed Image

After all these operations, we get a cleaned and enhanced image.

This preprocessed image is now ready for the edge detection stage, where actual plate boundaries
and text features are identified.

Entity Relationship Diagram(ER)

Vehicle
This entity represents details about a vehicle.

Attributes:
vehicle_id (Primary Key)
vehicle_license_no
vehicle_owner_id
vehicle_insurance_id
registration_id

Owner
This entity holds information about the owner of a vehicle.
Attributes:
owner_id (Primary Key)
PAT_NO (Possibly Personal Authentication Token or License Number)
personal_details
vehicle_id

Traffic Rules Violation

This entity tracks violations linked to specific vehicles and their owners.

Attributes:
owner_id (Foreign Key from Owner)
vehicle_id (Foreign Key from Vehicle)
Rules violated
total_fine

UML Package Diagram

Class: ImagePreprocessing
This class includes several functions, each with a specific role in improving the image:

1.convertToGrayScale()

Converts the RGB image to grayscale.

Reduces complexity and focuses on intensity levels.

2.resizeImage()
Adjusts image dimensions without distorting it.
Ensures consistent input size for further processing.

3.applyMorphologicalProcessing()

Enhances structural elements (like text and edges).

Uses operations like dilation and erosion.

4.convertToDouble()

Converts pixel values to double precision format.

Increases accuracy for mathematical operations.

5.increaseIntensity()

Enhances brightness or contrast for better visibility.

6.fillGaps()

Closes holes or broken parts in characters and objects.

7.removeUnwantedObjects()

Removes noise, small blobs, or irrelevant components from the image.

Class: EdgeDetection
detectEdges()

Applies edge detection algorithms (e.g., Canny, Sobel).Finds the boundaries of the license plate and
characters.

1.removeLines()

Removes horizontal/vertical lines that might interfere with text detection.

Improves clarity of extracted characters.

2.extractText()

Segments or extracts regions that likely contain license plate text.

Prepares image or data for OCR (optional next step)

Class: DisplaySystem

1.showDetectedEdges()

Displays the final edge-detected image to the user.

Could be a GUI window, image file output, or integration with OCR system.
UML Component diagram
(Sir I am using some other than StarUML (online websites app/drawio)

Image Processing
Role: Acts as the central coordinator that controls the flow of data between all other components.
Responsibilities:
Initiates preprocessing
Sends data to edge detection
Passes image to line and noise cleaning modules
Sends final result to display module

3. Preprocessing Module
Role: Prepares the image for edge detection by enhancing key features and reducing complexity.
Sub-components:
Grayscale Converter: Converts RGB image to grayscale
Image Resizer: Scales image while maintaining aspect ratio
Morphological Processor: Performs operations like dilation and erosion
Intensity Enhancer: Increases image contrast for better visibility
Double Converter: Converts image to double precision
Gap Filler: Fills in gaps between elements, useful for character connectivity

Edge Detection Module

Role: Detects edges in the preprocessed image.
Sub-component:
Edge Detector: Uses methods like Canny, Sobel, etc., to identify object boundaries (especially license
plate edges)

Line Removal Module

Role: Filters out extra lines that are not part of the license plate characters.
Sub-components:
Horizontal Line Filter: Removes horizontal noise lines
Vertical Line Filter: Removes vertical lines to isolate text

Noise Cleaning Module

Role: Cleans the image by removing small irrelevant objects.
Sub-component:
Small Object Remover: Removes specks or blobs that could interfere with text recognition

Display Module
Role: Outputs the final processed image.
Sub-component:
Output Viewer: Visual component that shows the final edge-detected image to the user

UML Collaboration Diagram

Message Flow Representation
# Sender → Receiver Message Purpose
1 User → UI uploadImage() The user uploads an image to begin processing.
2 UI → IPC startProcessing() UI triggers the processing pipeline.
3 IPC → Preproc preprocessImage() Preprocessing starts: grayscale, resize, enhance.
4 Preproc → IPC processedImage Preprocessed image is returned.
5 IPC → EdgeDet detectEdges() Edge detection is applied to processed image.
6 EdgeDet → IPC edgeData Detected edges are sent back.
Unnecessary lines are removed to isolate plate
7 IPC → LineRem removeLines()
text.
8 LineRem → IPC cleanedEdges Returns the filtered image.
9 IPC → NoiseClean removeNoise() Cleans leftover small unwanted objects.
10 NoiseClean → IPC finalCleanImage Final cleaned image is sent back.
11 IPC → Display displayResult() Processed result is sent to display.
12 Display → User showOutput() Final license plate edge detection result is shown.

UML Deployment Diagram

User Device is Camera and other hardware used in user side like capturing the vehicle_id
Display Server is Web-site for description of fines and how it happened

Processing Server
Represents: The backend server or system that performs all the heavy-lifting for image processing.

Contains the following artifacts:

ImageProcessingController: Orchestrates the image processing flow.

PreprocessingModule: Converts image to grayscale, resizes, enhances, etc.
EdgeDetectionModule: Detects edges using algorithms like Sobel or Canny.
LineRemovalModule: Removes vertical/horizontal lines from the edge-detected image.
NoiseCleaningModule: Removes small, irrelevant objects left after line removal.

Testing Phase
To verify that each module (preprocessing, edge detection, noise removal, etc.) and the system as a
whole works correctly and meets the intended functionality.

Unit Testing - Test each module individually (e.g., convertToGrayscale(), detectEdges()).

Tools you can use: Python’s unittest, pytest, or MATLAB scripts (depending on implementation).
ExTest Cases:
1.Check if grayscale conversion preserves image dimensions.
2.Validate if edge detection finds prominent contours.
3.Ensure morphological operations improve text clarity.

Integration Testing - Test how modules work together.

Ex:
Does the pipeline correctly process from image upload → preprocessing → edge detection → display?
Are outputs of one module correctly passed as inputs to the next?

System Testing -Validate the complete system behavior.

Scenarios to test:
1.Uploading different resolution images.
2.Plates with poor lighting, blurry images.
3.Running on different devices or browsers.

Performance Testing
Processing speed — how long does it take per image?
Memory usage.
Can it handle a batch of images?

User Acceptance Testing (UAT)

1.Can a user with no technical knowledge upload an image and understand the result?
UI is responsive and intuitive.
Error messages are clear (e.g., if image upload fails).
Output is readable and correctly highlights the plate edges.
We can apply Blackbox testing for each phase for fast analysis of bugs

Black box testing

Black box testing is a method where the internal code/logic is not examined. The tester only focuses
on inputs and expected outputs.
Focus on Functional Requirements
Ensures that:
Grayscale conversion works.
Edges are detected.
Noise is removed.
Final output is displayed.

TC ID Test Description Input Expected Output Test Type

TC001 Convert RGB to Grayscale Color image Grayscale image Unit
Resize Image while Large image (e.g., Resized image with same
TC002 Unit
maintaining aspect ratio 4000x3000) aspect ratio
Enhanced, smoothened
TC003 Morphological Processing Noisy text image Unit
characters
Double-precision format
TC004 Convert to Double Precision Grayscale image Unit
image
Brighter, contrast-enhanced
TC005 Intensity Enhancement Low contrast image Unit
image
Broken edge
TC006 Fill Gaps Closed edge loops Unit
contours
Image with random Cleaned image with fewer
TC007 Remove Unwanted Objects Unit
speckles artifacts
Edge Detection Highlighted contours of license
TC008 Preprocessed image Unit
Functionality plate
Remove Horizontal and Edge image with
TC009 Image with lines removed Unit
Vertical Lines lines
Only text-containing region
TC010 Extract Text Region Cleaned image Integration
visible
TC011 Input Image Upload via UI .jpg image Image preview appears System
Final image with clear license
TC012 Full Pipeline Execution Raw RGB image System
plate edges displayed
TC013 Output Display Verification Processed image Result shown to user on UI System
TC014 Large Image File Handling 10MB+ image Processed without crash Performance
Multiple Image Uploads Each processed correctly in
TC015 3 different images Integration
Sequentially sequence
Unsupported File Format Error: "Unsupported file
TC016 .txt file System
Upload format"
Message: "No plate detected"
TC017 Image with No License Plate Natural scenery System
or blank result
TC018 Blurry Image Input Low-quality image Still detects rough outline System
Time Taken to Process One Standard plate
TC019 < 5 seconds Performance
Image image
Cross-browser Chrome, Firefox,
TC020 Consistent output in all System/UAT
Compatibility Edge