Urine Strip Test Analysis Using Image Processing and Deep Learning

In the realm of medical diagnostics, automating the analysis of urine strip tests presents a significant opportunity for improving efficiency and accuracy. This article explores the application of image processing and deep learning techniques to streamline the analysis of urine strip tests. By leveraging these technologies, medical professionals can achieve faster and more consistent results, ultimately enhancing patient care. The integration of MATLAB in this process offers a robust platform for developing and deploying these automated solutions. This innovative approach promises to transform how urine strip tests are interpreted, making healthcare more accessible and reliable.

What is Urine Strip Test Analysis?

Urine strip tests are a common diagnostic tool used in Healthcare to detect various medical conditions by analyzing the components of urine. The process involves immersing a chemically treated strip into a urine sample, where different pads on the strip react with specific substances, causing color changes.

These color changes indicate the presence and concentration of substances such as glucose, protein, ketones, blood, leukocytes, nitrites, bilirubin, urobilinogen, and pH levels.

Traditionally, the interpretation of these tests is done visually by comparing the colors on the strip to a reference Chart provided by the manufacturer. However, visual interpretation is prone to subjectivity and variability due to factors such as lighting conditions, individual color Perception, and the experience level of the observer.

Automated urine strip test analysis seeks to eliminate these subjective factors by using technology to interpret the test results. This involves capturing an image of the urine strip, processing the image to identify and analyze the colors of the different pads, and then using algorithms to determine the concentration levels of the substances being tested. By automating this process, healthcare providers can obtain more consistent, accurate, and Timely results, leading to better patient care and more efficient use of resources. Image processing, deep learning, and software like MATLAB are crucial tools in developing these automated systems, making them reliable and accessible in various medical settings.

The Role of Image Processing and Deep Learning

Image processing and deep learning play a pivotal role in automating urine strip test analysis, enhancing both the accuracy and efficiency of the diagnostic process. Here’s a detailed look at how these technologies are applied:

Image Acquisition: The process begins with capturing a high-resolution image of the urine strip.

The quality of the image is crucial, as it directly affects the subsequent analysis. Factors such as lighting, angle, and focus must be controlled to ensure clear and consistent images.

Pre-processing: Once the image is captured, pre-processing steps are applied to enhance its quality and prepare it for further analysis. Common pre-processing techniques include:

• Noise Reduction: Applying filters to reduce noise and artifacts in the image, ensuring clearer color detection.
• Contrast Enhancement: Adjusting the contrast to make the color variations more pronounced.
• Color Correction: Correcting any color distortions caused by lighting or camera settings to ensure accurate color representation.

Segmentation: Segmentation involves isolating the individual pads on the urine strip. This step is critical for accurately analyzing each reaction. Techniques used for segmentation include:

• Edge Detection: Identifying the boundaries of each pad using edge detection algorithms.
• Thresholding: Applying thresholding techniques to separate the pads from the background.
• Contour Analysis: Analyzing the contours of the pads to accurately Delineate their shapes and positions.

Feature Extraction: After segmentation, the key features of each pad are extracted. The most important feature is the color of the pad, which is indicative of the concentration of the substance being tested. Color analysis involves:

• Color Space Conversion: Converting the image to a color space that is suitable for analysis, such as RGB, HSV, or CIELAB.
• Color Measurement: Measuring the average color values for each pad using statistical methods.
• Color Calibration: Calibrating the color measurements to a standard reference to ensure consistency and accuracy.

Classification: Classification is the final step, where the extracted features (colors) are used to determine the concentration levels of the substances being tested. Deep learning algorithms, particularly Convolutional Neural Networks (CNNs), are often used for this purpose.

• Training the Model: CNNs are trained on a large dataset of urine strip images with known concentrations. This allows the model to learn the complex relationships between the colors and the corresponding concentrations.
• Making Predictions: Once trained, the CNN can accurately classify new urine strip images, providing quantitative results for each parameter being tested.

By integrating image processing and deep learning, automated urine strip analysis systems can provide rapid, accurate, and objective results, enhancing diagnostic capabilities in various medical settings.

Setting Up the MATLAB Environment

MATLAB is a powerful platform for developing and deploying automated urine strip test analysis systems. It offers a wide range of tools and libraries specifically designed for image processing, deep learning, and data analysis.

Here’s a guide on setting up the MATLAB environment for this purpose:

1. Install MATLAB:

• If you haven’t already, download and install MATLAB from the MathWorks website. Ensure you have a valid license.

2. Install Necessary Toolboxes:

• MATLAB’s functionality is extended through toolboxes. For urine strip test analysis, the following toolboxes are essential:
  • Image Processing Toolbox: Provides functions for image analysis, enhancement, filtering, segmentation, and color space conversions.
  • Deep Learning Toolbox: Supports the design, training, and deployment of deep learning models, including CNNs.
  • Computer Vision Toolbox: Offers tools for object detection, feature extraction, and video processing.
  • Statistics and Machine Learning Toolbox: Includes functions for statistical analysis, classification, and regression.
• To install these toolboxes, open MATLAB and go to the Home tab. Click on Add-Ons and then Get Add-Ons. Search for each toolbox and click Install.

3. Setting Up the Project Directory:

• Create a dedicated directory for your urine strip analysis project. This will help keep your files organized. For example:

UrineStripAnalysisProject/
├── data/
├── images/
├── scripts/
├── models/
└── results/

• data/: Stores the training and testing datasets.
• images/: Contains sample images of urine strips.
• scripts/: Includes MATLAB scripts for image processing, deep learning, and analysis.
• models/: Stores trained deep learning models.
• results/: Holds the output and analysis results.

4. Changing the MATLAB Path:

• To ensure MATLAB can find your scripts and data, add the project directory to the MATLAB path. In the MATLAB command window, type:

cd 'E:\New folder\1. 2021-2022\\1.Matlab Image Processing projects youtube\urine strip code'

• This command changes the current directory to your project directory. MATLAB will now search for files in this directory and its subdirectories.

5. Testing the Setup:

• Create a simple MATLAB script (e.g., test_setup.m) to verify that all toolboxes are correctly installed and accessible:

% Test script to verify MATLAB setup

% Check if Image Processing Toolbox is installed
if license('test', 'Image_Toolbox')
    disp('Image Processing Toolbox is installed.');
else
    error('Image Processing Toolbox is not installed.');
end

% Check if Deep Learning Toolbox is installed
if license('test', 'Deep_Learning_Toolbox')
    disp('Deep Learning Toolbox is installed.');
else
    error('Deep Learning Toolbox is not installed.');
end

disp('MATLAB setup is complete.');

• Run the script by typing test_setup in the command window. If all toolboxes are correctly installed, you should see confirmation messages. Otherwise, you'll receive an error message indicating which toolbox is missing.

By following these steps, you’ll have a well-organized and fully equipped MATLAB environment ready for developing automated urine strip test analysis systems. This setup ensures that you have all the necessary tools and libraries to perform image processing, deep learning, and data analysis effectively.

Developing the Automated Analysis Script

Developing an automated analysis script in MATLAB involves several key steps, each contributing to the overall accuracy and efficiency of the system. Here’s a detailed guide to creating such a script:

1. Image Loading and Pre-processing:

• Start by loading the image of the urine strip into MATLAB. Use the imread function for this purpose:

% Load the image
image = imread('urine_strip_image.jpg');

% Display the image
imshow(image);
title('Original Image');

• Next, pre-process the image to enhance its quality. This includes noise reduction, contrast adjustment, and color correction:

% Convert to grayscale
grayImage = rgb2gray(image);

% Apply a median filter for noise reduction
filteredImage = medfilt2(grayImage, [3 3]);

% Adjust contrast using histogram equalization
adjustedImage = histeq(filteredImage);

% Display the pre-processed image
imshow(adjustedImage);
title('Pre-processed Image');

2. Strip Segmentation:

• Segment the urine strip from the background. Binarization helps to create a mask for segmentation. Use the following commands:

bw = imbinarize(adjustedImage); 
imshow(bw)

3. Pad Segmentation:

• Segment each color pad of the urine strip to isolate each testing parameter of the urine sample:

  
  segmentation = segmentImage(bw); 
  imshow(segmentation)

**4. Color Analysis and Feature Extraction:**

*   Extract the average color values from each pad. Convert the RGB values to a more suitable color space, such as HSV or CIELAB, for better color analysis:

```matlab
% Convert to HSV color space
hsvImage = rgb2hsv(image);

% Extract the Hue, Saturation, and Value channels
hueChannel = hsvImage(:, :, 1);
saturationChannel = hsvImage(:, :, 2);
valueChannel = hsvImage(:, :, 3);

% Calculate the average color values for each pad
meanHue = mean2(hueChannel(padMask));
meanSaturation = mean2(saturationChannel(padMask));
meanValue = mean2(valueChannel(padMask));

5. Classification and Result Interpretation:

• Use a pre-trained deep learning model (CNN) or a classification algorithm to interpret the extracted color features and determine the concentration levels:

% Load the trained CNN model
load('trainedCNNModel.mat', 'net');

% Prepare the input image for the CNN
resizedPadImage = imresize(padImage, [224 224]); % CNN input size

% Classify the pad image using the CNN
[predictedLabel, classScores] = classify(net, resizedPadImage);

% Display the results
disp(['Predicted Class: ' char(predictedLabel)]);
disp('Class Scores:');
disp(classScores);

6. Displaying the Results:

• Display the interpreted results in a user-friendly format. This could be a simple text output or a graphical display:

% Display the results
disp(['Leukocytes: ' result.Leukocytes]);
disp(['Nitrite: ' result.Nitrite]);
disp(['Blood: ' result.Blood]);
disp(['Glucose: ' result.Glucose]);

% You can also display a graphical representation of the results
figure;
bar([1 2 3 4], [result.LeukocytesValue result.NitriteValue result.BloodValue result.GlucoseValue]);
set(gca, 'XTickLabel', {'Leukocytes', 'Nitrite', 'Blood', 'Glucose'});
ylabel('Concentration Level');
title('Urine Strip Test Results');

7. Creating a User Interface (GUI):

• For ease of use, create a GUI using MATLAB’s App Designer or GUIDE. This allows users to load images and view the results in a more interactive manner:

% Example GUI code (using GUIDE or App Designer)
function analyzeButton_Callback(hObject, eventdata, handles)
    % Load the image
    [filename, pathname] = uigetfile({'*.jpg;*.jpeg;*.png;*.bmp', 'Image Files (*.jpg, *.jpeg, *.png, *.bmp)'}, 'Select an Image');
    if isequal(filename,0)
       return;
    end
    imagePath = fullfile(pathname, filename);
    image = imread(imagePath);

    % Pre-process, segment, analyze, and classify the image
    results = analyzeUrineStrip(image);

    % Display the results in the GUI
    set(handles.leukocytesText, 'String', ['Leukocytes: ' results.Leukocytes]);
    set(handles.nitriteText, 'String', ['Nitrite: ' results.Nitrite]);
    set(handles.bloodText, 'String', ['Blood: ' results.Blood]);
    set(handles.glucoseText, 'String', ['Glucose: ' results.Glucose]);
end

By following these steps and integrating the code snippets into a comprehensive MATLAB script, you can develop an automated urine strip test analysis system that provides rapid, accurate, and objective results. Ensure to adapt and refine the code based on your specific requirements and the characteristics of your urine strip images.

Training a Deep Learning Model for Classification

Training a deep learning model, specifically a Convolutional Neural Network (CNN), is crucial for accurate classification in automated urine strip test analysis. This section outlines the steps to train a CNN using MATLAB.

1. Data Collection and Preparation:

• Gather a large dataset of urine strip images with known concentrations for each parameter (e.g., glucose, protein, ketones, blood). Aim for at least several hundred images per class to ensure robust training.

  Each color pad must have images assigned to 5 classes:

  • Negative
  • Trace
  • Small
  • Moderate
  • Large
• Label each image with the corresponding concentrations or class labels. Organize the data into a structured format, such as separate folders for each class.

2. Data Augmentation:

• To increase the size and diversity of the training dataset, apply data augmentation techniques. This helps prevent overfitting and improves the model's generalization ability. Common augmentation methods include:
  • Rotation: Rotate images by small angles.
  • Scaling: Zoom in and out of images.
  • Translation: Shift images horizontally and vertically.
  • Flipping: Flip images horizontally or vertically.
  • Brightness Adjustment: Vary the brightness of images.
• Use MATLAB’s imageDatastore and augmentedImageDatastore functions to efficiently manage and augment the image data:

% Create an image datastore
imds = imageDatastore('path_to_your_data', 'IncludeSubfolders', true, 'LabelSource', 'foldernames');

% Split the data into training and validation sets
[imdsTrain, imdsValidation] = splitEachLabel(imds, 0.8, 'randomized');

% Create an augmented image datastore for training
imageSize = [224 224 3]; % CNN input size
augmenter = imageDataAugmenter(
    'RandRotation', [-10, 10],
    'RandXTranslation', [-20 20],
    'RandYTranslation', [-20 20],
    'RandXReflection', true,
    'RandYReflection', true
);
augmentedTrainingSet = augmentedImageDatastore(imageSize, imdsTrain, 'DataAugmentation', augmenter);

% Augmented image datastore for validation (no augmentation)
augmentedValidationSet = augmentedImageDatastore(imageSize, imdsValidation);

3. Model Selection and Architecture:

• Choose a suitable CNN architecture. Popular choices include AlexNet, VGGNet, ResNet, or a custom-designed CNN. For this example, we’ll use a pre-trained AlexNet and fine-tune it for our task:

% Load the pre-trained AlexNet
net = alexnet;

% Inspect the network architecture
layers = net.Layers;

% Modify the network for our classification task
numClasses = numel(categories(imdsTrain.Labels));
layers(end-2) = fullyConnectedLayer(numClasses);
layers(end-1) = softmaxLayer;
layers(end) = classificationLayer;

% Verify the modified layers
layers = net.Layers;

4. Training Options:

• Configure the training options, such as the learning rate, batch size, number of epochs, and optimization algorithm:

% Training options
options = trainingOptions('sgdm',
    'MiniBatchSize', 32,
    'MaxEpochs', 10,
    'InitialLearnRate', 0.001,
    'ValidationData', augmentedValidationSet,
    'ValidationFrequency', 3,
    'Verbose', false,
    'Plots', 'training-progress');

5. Model Training:

• Train the CNN using the prepared training data and the specified training options:

% Train the CNN
[trainedNet, trainingInfo] = trainNetwork(augmentedTrainingSet, layers, options);

6. Model Evaluation:

• Evaluate the trained model using the validation dataset to assess its performance. Calculate metrics such as accuracy, precision, recall, and F1-score:

% Evaluate the model
[YPred, scores] = classify(trainedNet, augmentedValidationSet);
YValidation = imdsValidation.Labels;
accuracy = mean(YPred == YValidation);

% Display the accuracy
disp(['Validation Accuracy: ' num2str(accuracy*100) '%']);

% Calculate the confusion matrix
confusionchart(YValidation, YPred);

7. Fine-Tuning and Optimization:

• If the model's performance is not satisfactory, fine-tune the hyperparameters, adjust the network architecture, or Collect more training data. Repeat the training and evaluation process until the desired performance is achieved.

8. Save the Trained Model:

• Save the trained model for future use:

% Save the trained model
save('trainedCNNModel.mat', 'trainedNet');

By following these steps, you can train a robust deep learning model for accurate classification in automated urine strip test analysis. This model can then be integrated into the complete analysis script to provide reliable and objective results.

Loading and Preparing the Image

The initial step involves loading the urine strip image into MATLAB and preparing it for analysis. Follow these steps:

1. Load the Image:

• Use the imread function to load the image into MATLAB. Specify the path to your image file:

image = imread('urine_strip_image.jpg');

2. Display the Original Image:

• Display the loaded image to ensure it has been read correctly:

imshow(image);
title('Original Image');

3. Convert to Grayscale:

• Convert the image to grayscale to simplify subsequent processing steps. This reduces the color image to a single Channel:

grayImage = rgb2gray(image);

4. Apply Noise Reduction:

• Reduce noise in the image using a median filter. This helps to smooth the image while preserving edges:

filteredImage = medfilt2(grayImage, [3 3]);

5. Adjust Contrast:

• Improve contrast using histogram equalization to enhance the visibility of details:

adjustedImage = histeq(filteredImage);

6. Display the Pre-processed Image:

• Show the pre-processed image to verify the effectiveness of the noise reduction and contrast adjustment steps:

imshow(adjustedImage);
title('Pre-processed Image');

By completing these steps, you ensure that the image is properly loaded and prepared, setting the stage for accurate segmentation and analysis in the following stages.

Binarization and Masking

Binarization and masking are essential techniques for segmenting the urine strip from the background. Here’s how to perform these steps:

1. Binarization:

• Convert the pre-processed grayscale image into a binary image using thresholding. This simplifies the image into black and white, making it easier to segment the strip:

bw = imbinarize(adjustedImage);

2. Display the Binary Image:

• Show the binary image to ensure the strip is clearly segmented:

imshow(bw);
title('Binary Image');

3. Segmentation Function:

• Call the segmentation function:

segmentation = segmentImage(bw);

4. Display the Segmentation:

• Display to check the correct segmentation of all color pads:

imshow(segmentation);
title('Segmentation Image');

By following these steps, you create a clear binary mask that isolates the urine strip, enabling further analysis focused solely on the Relevant areas.

Color Analysis and Classification

After segmenting the pads, the next step is to analyze the color of each pad and classify the results. Here’s how to do it:

1. Color Space Conversion:

• Convert the RGB image to the HSV color space, which is more suitable for color analysis. Define the color pad:

padImage = image(rectangle(2):rectangle(4), rectangle(1):rectangle(3),:);

2. Average Value:

• Calculate the average RGB and HSV:

rgb_avg = mean(mean(padImage,1),2);
hsv_avg = mean(mean(rgb2hsv(padImage),1),2);

3. CNN model:

• Load the trained CNN model to classify the color features:

load('trainedCNNModel.mat', 'net');

4. CNN Image Pre-processing:

• Apply CNN pre-processing:

resizedPadImage = imresize(padImage, [224 224]); % CNN input size

5. Classification:

• Classify to determine the color:

[predictedLabel, classScores] = classify(net, resizedPadImage);

6. Data Output:

• Output the average values with the concentration levels determined by the deep learning model.

By integrating these steps, you achieve automated color analysis and classification, providing quantitative results that enhance the objectivity and accuracy of urine strip test interpretation.

MATLAB Licensing

To implement automated urine strip test analysis using MATLAB, you need a valid MATLAB license. MATLAB offers various licensing options to suit different needs and budgets. These include:

• Individual License: Suitable for personal use, this license provides access to MATLAB and its toolboxes on a single computer.
• Commercial License: Designed for businesses and organizations, this license allows multiple users to access MATLAB and its toolboxes. It also includes additional support and maintenance services.
• Academic License: Intended for educational institutions and students, this license provides discounted access to MATLAB and its toolboxes for teaching and research purposes.

The pricing for MATLAB licenses varies depending on the type of license and the specific toolboxes included. It is recommended to visit the MathWorks website for detailed pricing information and to request a quote based on your requirements.

For developers interested in modifying or purchasing the source code for the urine strip test analysis system, specific licensing terms and pricing can be obtained by contacting the developer directly through the link provided in the video description or by sending a message to the WhatsApp number Mentioned in the video.

Core Functionalities

The automated urine strip test analysis system offers several core features that enhance the efficiency and accuracy of the diagnostic process:

• Automated Image Processing:
  • The system automates the entire image processing pipeline, from loading the image to pre-processing, segmentation, and feature extraction. This reduces the manual effort required and ensures consistent results.
• Deep Learning-Based Classification:
  • The system employs a trained deep learning model (CNN) to accurately classify the color features of each pad on the urine strip. This provides objective and quantitative results for each parameter being tested.
• User-Friendly GUI:
  • The system includes a graphical user interface (GUI) that allows users to easily load images, view the analysis results, and interact with the system. The GUI enhances the user experience and makes the system accessible to users with varying levels of technical expertise.
• Customizable Analysis Parameters:
  • The system allows users to customize the analysis parameters, such as the color space, segmentation thresholds, and classification algorithms. This provides flexibility and allows users to adapt the system to their specific requirements.
• Data Storage and Reporting:
  • The system includes data storage and reporting capabilities, allowing users to store the analysis results in a database and generate reports for further analysis and documentation. This enhances the traceability and accountability of the diagnostic process.

Applications in Healthcare

The automated urine strip test analysis system can be applied in various medical settings to improve the efficiency and accuracy of urine analysis:

• Point-of-Care Testing:
  • The system can be used in point-of-care testing scenarios, such as clinics, emergency rooms, and ambulances, to provide rapid and accurate urine analysis results. This enables healthcare providers to make informed decisions quickly and improve patient outcomes.
• Laboratory Automation:
  • The system can be integrated into laboratory automation systems to streamline the urine analysis workflow. This reduces the manual effort required, minimizes human errors, and increases the throughput of the laboratory.
• Remote Diagnostics:
  • The system can be used in remote diagnostics scenarios, such as telemedicine and home healthcare, to enable patients to perform urine tests at home and transmit the results to their healthcare providers. This improves access to healthcare for patients in remote or underserved areas.
• Clinical Research:
  • The system can be used in clinical research studies to collect and analyze urine data from large patient populations. This provides valuable insights into the prevalence, incidence, and risk factors for various medical conditions.