1. CMAG: IoT Baby Monitor Using Eulerian Video Magnification
Advanced
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Prevent Sudden Infant Death Syndrome (SIDS) by detecting infant respiration and subtle chest movements using video-based Eulerian Motion Magnification to amplify sub-visual pixel changes and trigger IoT alert alarms.
⚙️ Key MATLAB Functions:
rgb2ntscimfilterbuildpyrVideoReaderbutter
📊 Expected Output & Metrics: Magnified motion video stream, breathing rate time series (BPM), motion threshold alarm trigger, and respiration SNR (>18 dB).
v = VideoReader('infant_crib_sleep.mp4');
fs = v.FrameRate; alpha = 30;
fl = 0.2; fh = 0.8;
[b, a] = butter(2, [fl fh]/(fs/2), 'bandpass');
while hasFrame(v)
frame = im2double(readFrame(v));
yiq = rgb2ntsc(frame);
filtered_Y = filter(b, a, yiq(:,:,1));
yiq(:,:,1) = yiq(:,:,1) + alpha * filtered_Y;
amplified_frame = ntsc2rgb(yiq);
end
Est. Duration: 3–4 Weeks
Request Custom Project →
2. Hand Reader – Hand Geometry Biometric Verification System
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Develop a contact-free biometric identity verification system using webcam hand silhouette images to segment palm and finger geometry, extract 16-element feature vectors, and perform Euclidean distance matching.
⚙️ Key MATLAB Functions:
imbinarizeregionpropsbwboundariesnormxcorr2pdist2
📊 Expected Output & Metrics: Segmented hand contour, extracted finger length/width feature vector, False Acceptance Rate (FAR < 0.5%), and False Rejection Rate (FRR < 1.2%).
I = imread('hand_sample.jpg');
I_gray = rgb2gray(I);
BW = ~imbinarize(I_gray, graythresh(I_gray));
BW = bwareafilt(BW, 1);
boundaries = bwboundaries(BW);
stats = regionprops(BW, 'Centroid', 'MajorAxisLength', 'MinorAxisLength', 'ConvexHull');
centroid = stats.Centroid;
dist_profile = pdist2(boundaries{1}, centroid);
[pks, locs] = findpeaks(dist_profile, 'MinPeakDistance', 40);
Est. Duration: 1–2 Weeks
Request Custom Project →
3. Smart NDVI Camera System for Outdoor Plant Detection
Advanced
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Compute Normalized Difference Vegetation Index (NDVI) from Near-Infrared (NIR) and Red optical channels to distinguish green crop biomass from background soil in smart precision agriculture.
⚙️ Key MATLAB Functions:
imabsdiffimregistercolormapimhistimregconfig
📊 Expected Output & Metrics: NDVI color map visualization, plant cover percentage estimation, background soil suppression ratio, and real-time processing throughput.
nir = im2double(imread('field_nir.png'));
red = im2double(imread('field_red.png'));
[optimizer, metric] = imregconfig('multimodal');
nir_reg = imregister(nir, red, 'affine', optimizer, metric);
ndvi = (nir_reg - red) ./ (nir_reg + red + eps);
veg_mask = ndvi > 0.35;
figure; imagesc(ndvi); colormap(jet); colorbar;
title('Crop Health & NDVI Biomass Map');
Est. Duration: 2–3 Weeks
Request Custom Project →
4. Image Decomposition for Low-Dose CT Medical Image Processing
Advanced
Toolbox: Image Processing, Wavelet, Medical Imaging
Deliverables: Code .m, Report
🎯 Problem & Objective: Decompose low-dose medical X-ray CT scans into multiscale frequency subbands using 2D Wavelet transforms and patch dictionary learning to eliminate quantum mottle noise while preserving critical organ boundaries.
⚙️ Key MATLAB Functions:
wavedec2waverec2wthrmngrpsnrimmse
📊 Expected Output & Metrics: Multiscale subband decompositions, noise-reduced CT output, PSNR gain (>36 dB), and Contrast-to-Noise Ratio (CNR enhancement).
ct_noisy = im2double(imread('low_dose_ct_slice.png'));
[c, s] = wavedec2(ct_noisy, 3, 'sym4');
sigma = median(abs(detcoef2('all', c, s, 1))) / 0.6745;
thr = sigma * sqrt(2 * log(numel(ct_noisy)));
c_denoised = wthrmngr('dw2dcompGBL', 'bal_sn', c, s, thr);
ct_clean = waverec2(c_denoised, s, 'sym4');
psnr_val = psnr(ct_clean, ct_noisy);
Est. Duration: 3–4 Weeks
Request Custom Project →
5. Automated Road Extraction from High-Resolution Satellite Images
Intermediate
Toolbox: Image Processing, Mapping
Deliverables: Code .m, Report
🎯 Problem & Objective: Automatically detect and trace urban/rural road networks from high-resolution satellite imagery using morphological thinning, directional filtering, and connected component skeletonization.
⚙️ Key MATLAB Functions:
edgeimopenbwmorphbwskelhoughlines
📊 Expected Output & Metrics: Binary road network mask, extracted centerline vector GIS overlay, road completeness ratio (>88%), and correctness precision metric.
sat_img = imread('satellite_urban.tif');
gray = rgb2gray(sat_img);
BW_edges = edge(gray, 'Canny', [0.08 0.2]);
se = strel('disk', 3);
BW_closed = imclose(BW_edges, se);
BW_clean = bwareafilt(BW_closed, [200 inf]);
road_skeleton = bwskel(BW_clean, 'MinBranchLength', 20);
figure; imshow(sat_img); hold on;
visboundaries(road_skeleton, 'Color', 'y', 'LineWidth', 2);
Est. Duration: 1–2 Weeks
Request Custom Project →
6. Multiscale Edge-Based Text Extraction in Complex Scenes
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Localize and extract text regions from complex background scenes, street signage, and degraded document scans using multiscale Gaussian/Laplacian edge filtering and OCR parsing.
⚙️ Key MATLAB Functions:
edgeimpyramidregionpropsocrinsertShape
📊 Expected Output & Metrics: Text bounding box overlays, extracted text binary masks, OCR character recognition accuracy (>92%), and detection recall rate.
img = imread('street_sign_complex.jpg');
gray = rgb2gray(img);
pyramid1 = impyramid(gray, 'reduce');
edges = edge(gray, 'Sobel', 0.05);
se_text = strel('rectangle', [3 12]);
BW_text = imdilate(edges, se_text);
stats = regionprops(BW_text, 'BoundingBox', 'Area', 'Eccentricity');
ocrResults = ocr(gray, vertcat(stats.BoundingBox));
disp(ocrResults.Text);
Est. Duration: 1–2 Weeks
Request Custom Project →
7. Abandoned Luggage & Object Detection in Crowded Surveillance
Advanced
Toolbox: Computer Vision, Image Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Monitor human trajectories and static items in crowded security video feeds to identify abandoned luggage events by tracking spatio-temporal owner-object separations.
⚙️ Key MATLAB Functions:
vision.KalmanFiltervision.ForegroundDetectorinsertObjectAnnotationvision.BlobAnalysis
📊 Expected Output & Metrics: Pedestrian/luggage trajectory tracks, abandoned bag timestamp alarm alerts, owner distance thresholding, and false alarm rate (<2%).
detector = vision.ForegroundDetector('NumGaussians', 5, 'NumTrainingFrames', 60);
blob = vision.BlobAnalysis('MinimumBlobArea', 250);
while hasFrame(videoReader)
frame = readFrame(videoReader);
fgMask = detector(frame);
[areas, centroids, bboxes] = blob(fgMask);
outFrame = insertObjectAnnotation(frame, 'rectangle', bboxes, 'Luggage Track');
end
Est. Duration: 3–4 Weeks
Request Custom Project →
8. Hand Gesture Recognition for Robot Teleoperation via Skin Segmentation
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Isolate hand regions using YCbCr color thresholding, extract normalized contour moments and PCA eigenspaces, and classify static/dynamic gestures for wireless robot teleoperation.
⚙️ Key MATLAB Functions:
rgb2ycbcrimbinarizepcafitcknnpredict
📊 Expected Output & Metrics: Skin segmentation binary map, PCA feature space projection plot, confusion matrix, and gesture classification accuracy (>93%).
I = imread('gesture_palm.jpg');
ycbcr = rgb2ycbcr(I);
Cb = ycbcr(:,:,2); Cr = ycbcr(:,:,3);
skin_mask = (Cb >= 77 & Cb <= 127) & (Cr >= 133 & Cr <= 173);
stats = regionprops(skin_mask, 'HuMoments', 'Eccentricity', 'Solidity');
features = [stats.Solidity, stats.Eccentricity];
predicted_gesture = predict(trained_knn_model, features);
Est. Duration: 1–2 Weeks
Request Custom Project →
9. Digital Image Arnold Transformation & RC4 Stream Encryption
Intermediate
Toolbox: Image Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Secure digital images through a 2-stage hybrid cryptographic scheme using Arnold Cat Map 2D matrix scrambling followed by RC4 pseudorandom bitwise XOR stream cipher diffusion.
⚙️ Key MATLAB Functions:
bitxorrandiimhistcorr2entropy
📊 Expected Output & Metrics: Scrambled/encrypted image visualizations, uniform histogram distribution, adjacent pixel correlation (<0.005), and NPCR (>99.6%)/UACI (>33.4%) metrics.
I = imread('cameraman.tif'); [N, ~] = size(I);
scrambled = I; a = 1; b = 1; iterations = 10;
for it = 1:iterations
temp = scrambled;
for x = 0:N-1
for y = 0:N-1
nx = mod(x + b*y, N);
ny = mod(a*x + (a*b+1)*y, N);
scrambled(ny+1, nx+1) = temp(y+1, x+1);
end
end
end
key = uint8(randi([0 255], size(I)));
encrypted = bitxor(scrambled, key);
Est. Duration: 1–2 Weeks
Request Custom Project →
10. JPEG Compressor Pipeline via 8x8 Discrete Cosine Transform (DCT)
Beginner
Toolbox: Image Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Implement the standard baseline JPEG compression pipeline: 8x8 block Discrete Cosine Transform (DCT), standard luminance quantization matrix application, zigzag vectorization, and inverse IDCT reconstruction.
⚙️ Key MATLAB Functions:
dct2idct2blockprocpsnrimshow
📊 Expected Output & Metrics: Reconstructed image at varying quality factors (Q=10 to 90), Compression Ratio (CR > 15:1), PSNR curves, and blocking artifact evaluations.
Q50 = [16 11 10 16 24 40 51 61; 12 12 14 19 26 58 60 55;
14 13 16 24 40 57 69 56; 14 17 22 29 51 87 80 62;
18 22 37 56 68 109 103 77; 24 35 55 64 81 104 113 92;
49 64 78 87 103 121 120 101; 72 92 95 98 112 100 103 99];
I = double(imread('cameraman.tif')) - 128;
dct_quant = @(b) round(dct2(b.data) ./ Q50);
I_quant = blockproc(I, [8 8], dct_quant);
idct_dequant = @(b) idct2(b.data .* Q50);
I_recon = blockproc(I_quant, [8 8], idct_dequant) + 128;
disp(['Reconstruction PSNR: ', num2str(psnr(uint8(I_recon), uint8(I+128))), ' dB']);
Est. Duration: 4–6 Hours
Request Custom Project →
11. Reversible Data Hiding & Secret Steganography in Encrypted Images
Intermediate
Toolbox: Image Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Embed secret binary payloads into encrypted images using prediction-error histogram modification, ensuring independent lossless image decryption and payload recovery with zero error.
⚙️ Key MATLAB Functions:
bitgetbitsetbitxorpsnrcorr2
📊 Expected Output & Metrics: Stego-encrypted image display, 100% extracted data bit accuracy (BER=0), PSNR of restored cover image (>45 dB), and embedding capacity (0.8+ bpp).
cover = imread('lena512.bmp');
enc_key = uint8(randi([0 255], size(cover)));
enc_img = bitxor(cover, enc_key);
secret_payload = randi([0 1], 1, 10000);
stego_enc = enc_img;
for k = 1:length(secret_payload)
stego_enc(k) = bitset(stego_enc(k), 1, secret_payload(k));
end
extracted_bits = bitget(stego_enc(1:length(secret_payload)), 1);
ber = sum(extracted_bits ~= secret_payload) / length(secret_payload);
disp(['Bit Error Rate (BER): ', num2str(ber)]);
Est. Duration: 1–2 Weeks
Request Custom Project →
12. Automatic Vehicle Number Plate Recognition (ANPR / ALPR)
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Locate vehicle license plates in outdoor road camera frames using top-hat filtering and vertical Sobel gradients, isolate alphanumeric characters via connected bounding boxes, and extract text via OCR.
⚙️ Key MATLAB Functions:
edgeimcloseregionpropsocrimtophat
📊 Expected Output & Metrics: Isolated license plate crop, segmented character masks, recognized alphanumeric plate string, and recognition accuracy (>95%).
car_img = imread('vehicle_rear.jpg');
gray = rgb2gray(car_img);
tophat = imtophat(gray, strel('disk', 12));
BW_edges = edge(tophat, 'Sobel', 'vertical');
BW_clean = imclose(BW_edges, strel('rectangle', [4 16]));
stats = regionprops(BW_clean, 'BoundingBox', 'Area', 'Eccentricity');
aspect_ratios = [stats.BoundingBox];
plate_crop = imcrop(gray, stats(1).BoundingBox);
txt = ocr(plate_crop, 'CharacterSet', '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ');
disp(['Detected Plate: ', txt.Text]);
Est. Duration: 1–2 Weeks
Request Custom Project →
13. Mammogram Breast Cancer Microcalcification Detection & CLAHE
Advanced
Toolbox: Image Processing, Medical Imaging
Deliverables: Code .m, Report
🎯 Problem & Objective: Enhance digital mammographic X-ray scans using Contrast-Limited Adaptive Histogram Equalization (CLAHE) and unsharp masking to segment microcalcification clusters using Chan-Vese active contours.
⚙️ Key MATLAB Functions:
adapthisteqimsharpenactivecontourregionpropsperfcurve
📊 Expected Output & Metrics: Enhanced contrast mammogram visualizations, segmented tumor contour boundaries, ROC curves, and AUC score (>0.94).
mammo = imread('mammogram_dcm.png');
mammo_clahe = adapthisteq(mammo, 'ClipLimit', 0.02, 'Distribution', 'rayleigh');
mammo_sharp = imsharpen(mammo_clahe, 'Radius', 2, 'Amount', 1.5);
mask_init = false(size(mammo));
mask_init(100:300, 150:350) = true;
tumor_mask = activecontour(mammo_sharp, mask_init, 250, 'Chan-Vese');
figure; imshow(mammo_sharp); hold on;
visboundaries(tumor_mask, 'Color', 'r', 'LineWidth', 2);
title('Detected Malignant Tumor Boundary');
Est. Duration: 3–4 Weeks
Request Custom Project →
14. Brain Tumour Extraction from T2-Weighted MRI Images Using Watershed
Intermediate
Toolbox: Image Processing, Medical Imaging
Deliverables: Code .m, Report
🎯 Problem & Objective: Isolate brain tumor neoplasms from T2-weighted MRI brain scans using 2D median filtering, automated skull-stripping masks, distance-transform watershed segmentation, and morphological opening.
⚙️ Key MATLAB Functions:
medfilt2watershedbwdistimextendedminbwlabel
📊 Expected Output & Metrics: Tumor boundary isolation mask, calculated tumor area (mm²), Dice similarity coefficient (>0.91), and execution latency.
mri = imread('mri_brain_axial.png');
mri_clean = medfilt2(mri, [3 3]);
brain_mask = imbinarize(mri_clean, graythresh(mri_clean));
D = -bwdist(~brain_mask);
mask_min = imextendedmin(D, 2);
D_mod = imimposemin(D, mask_min);
L = watershed(D_mod);
tumor = (L == 0) & (mri_clean > 180);
figure; imshow(mri); hold on;
visboundaries(tumor, 'Color', 'g', 'LineWidth', 2);
Est. Duration: 1–2 Weeks
Request Custom Project →
15. Multimodal Biometric Sensing System (Face & Fingerprint Fusion)
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Fuse face and fingerprint biometric traits at the score/decision levels to evaluate verification accuracy improvements and Equal Error Rate (EER) reductions over individual unimodal matchers.
⚙️ Key MATLAB Functions:
matchFeaturesextractFeaturesdetectSURFFeaturesperfcurve
📊 Expected Output & Metrics: Fusion verification score distributions, Equal Error Rate (EER < 0.4%), FAR/FRR trade-off curves, and unimodal vs multimodal comparative tables.
pts_face = detectSURFFeatures(face_img);
[feat_face, valid_face] = extractFeatures(face_img, pts_face);
score_face = matchFeatures(feat_face, template_face, 'Metric', 'SSD');
norm_face = (score_face - min(score_face)) / (max(score_face) - min(score_face));
norm_finger = (score_finger - min(score_finger)) / (max(score_finger) - min(score_finger));
fused_score = 0.55 * norm_face + 0.45 * norm_finger;
[X, Y, T, AUC] = perfcurve(labels, fused_score, 1);
Est. Duration: 1–2 Weeks
Request Custom Project →
16. Workplace Ergonomic Posture Assessment with Kinect RGB-D Sensors
Advanced
Toolbox: Computer Vision, Image Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Monitor seated office worker posture using Kinect RGB-Depth streams to detect ergonomic spine/wrist misalignments, calculate 3D joint angles, and trigger automated biofeedback warning alerts.
⚙️ Key MATLAB Functions:
pcfitplanereadFramepcreadfitgeotransatan2d
📊 Expected Output & Metrics: 3D skeleton joint angle time series (spine/neck/elbow), ergonomic RULA risk rating scores (1-7), and real-time posture alert logs.
neck = joint_pts(1, :); spine = joint_pts(2, :); hip = joint_pts(3, :);
v1 = neck - spine; v2 = hip - spine;
trunk_angle = acosd(dot(v1, v2) / (norm(v1) * norm(v2)));
if trunk_angle > 20
warning('Ergonomic Warning: Unhealthy Spine Flexion Detected!');
end
Est. Duration: 3–4 Weeks
Request Custom Project →
17. Perspective Distortion Modeling & Spatial Homography in Face Images
Advanced
Toolbox: Computer Vision, Image Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Model perspective distortion in close-up face selfies as parametric 2D/3D projective warping functions to rectify facial proportions and improve recognition robustness across variable focal lengths.
⚙️ Key MATLAB Functions:
imwarpfitgeotform2dvision.PointTrackerdetectMinEigenFeatures
📊 Expected Output & Metrics: Homography-rectified face portrait outputs, facial landmark stability, face identification accuracy boost (+14%), and real-time tracking speed (FPS).
face_distorted = imread('selfie_close_up.jpg');
moving_pts = [120 180; 240 180; 180 230; 150 290; 210 290];
fixed_pts = [130 170; 230 170; 180 220; 150 280; 210 280];
tform = fitgeotform2d(moving_pts, fixed_pts, 'projective');
face_corrected = imwarp(face_distorted, tform, 'OutputView', imref2d(size(face_distorted)));
Est. Duration: 2–3 Weeks
Request Custom Project →
18. Pest & Crop Disease Detection in Agricultural Plantations
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Detect and classify pest infestation lesions on crop leaves using RGB to HSV color transformations, K-means color clustering segmentation, and Gray-Level Co-occurrence Matrix (GLCM) texture descriptors.
⚙️ Key MATLAB Functions:
rgb2hsvkmeansgraycomatrixgraycopropsfitcecoc
📊 Expected Output & Metrics: Segmented leaf lesion masks, affected leaf area percentage, disease severity index, and pest classification accuracy (>94%).
leaf = imread('cotton_pest_leaf.jpg');
hsv = rgb2hsv(leaf);
data = reshape(hsv, [], 3);
[idx, ~] = kmeans(data, 3);
lesion_mask = reshape(idx == 2, size(leaf, 1), size(leaf, 2));
gray_lesion = rgb2gray(leaf) .* uint8(lesion_mask);
glcm = graycomatrix(gray_lesion, 'Offset', [0 1; -1 1; -1 0; -1 -1]);
stats = graycoprops(glcm, {'Contrast', 'Correlation', 'Energy', 'Homogeneity'});
Est. Duration: 1–2 Weeks
Request Custom Project →
19. Intelligent Traffic Light Control via Vehicle Density Estimation
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Regulate traffic junction green light signal times dynamically based on real-time vehicle density computed via background frame subtraction and morphological object counting on road camera feeds.
⚙️ Key MATLAB Functions:
imabsdiffimbinarizeimdilateregionpropsbwareaopen
📊 Expected Output & Metrics: Real-time vehicle count per road lane, adaptive green light timer schedule (15-90s), background subtraction masks, and junction idle reduction (>35%).
bg_frame = rgb2gray(imread('empty_road.jpg'));
live_frame = rgb2gray(imread('traffic_jam.jpg'));
diff = imabsdiff(live_frame, bg_frame);
BW = imbinarize(diff, 0.15);
BW_clean = bwareaopen(imdilate(BW, strel('disk', 3)), 150);
stats = regionprops(BW_clean, 'Area');
vehicle_count = length(stats);
green_time_sec = min(max(15, vehicle_count * 3.5), 90);
disp(['Vehicles: ', num2str(vehicle_count), ' | Green Phase: ', num2str(green_time_sec), 's']);
Est. Duration: 1–2 Weeks
Request Custom Project →
20. Real-Time Face & Feature Detection via Viola-Jones Haar Cascades
Beginner
Toolbox: Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Implement the Viola-Jones Haar-like cascade object detection pipeline in MATLAB to locate human frontal faces, eyes, and upper bodies in static images and live webcam streams.
⚙️ Key MATLAB Functions:
vision.CascadeObjectDetectorstepinsertObjectAnnotationwebcam
📊 Expected Output & Metrics: Real-time bounding box face/eye overlays, processing frame rate (FPS > 30), detection recall rate (>96%), and low false positive rate.
faceDetector = vision.CascadeObjectDetector('FrontalFaceCART');
eyeDetector = vision.CascadeObjectDetector('EyePairBig');
img = imread('crowd_faces.jpg');
bboxes_face = faceDetector(img);
bboxes_eye = eyeDetector(img);
out = insertObjectAnnotation(img, 'rectangle', bboxes_face, 'Face', 'Color', 'yellow');
out = insertObjectAnnotation(out, 'rectangle', bboxes_eye, 'Eyes', 'Color', 'cyan');
figure; imshow(out);
Est. Duration: 4–6 Hours
Request Custom Project →
21. Face Recognition System Using 2D-DCT & Self-Organizing Maps (SOM)
Intermediate
Toolbox: Image Processing, Deep Learning
Deliverables: Code .m, Report
🎯 Problem & Objective: Compress face images using 2D Discrete Cosine Transform (2D-DCT) to extract compact low-frequency spectral descriptors and classify individual identities using unsupervised Self-Organizing Maps (SOM).
⚙️ Key MATLAB Functions:
dct2selforgmaptrainplotsomhitsvec2ind
📊 Expected Output & Metrics: 2D-DCT feature vector matrix, SOM training convergence plots, identity classification accuracy (85%+), and identification latency.
I = im2double(imresize(rgb2gray(imread('subject1.jpg')), [64 64]));
dct_matrix = dct2(I);
features = dct_matrix(1:8, 1:8);
feat_vec = features(:);
net = selforgmap([6 6]);
net.trainParam.epochs = 400;
net = train(net, all_training_features);
y = net(feat_vec);
cluster_id = vec2ind(y);
Est. Duration: 1–2 Weeks
Request Custom Project →
22. Wavelet-Based Image Compression on Texas Instruments DSP Hardware
Advanced
Toolbox: Image Processing, Wavelet, MATLAB Coder
Deliverables: Code .m, Report
🎯 Problem & Objective: Compare DCT vs DWT (JPEG2000) image compression architectures in MATLAB, evaluate rate-distortion curves, and generate optimized standalone C code for deployment onto a TI TMS320DM6437 DSP board.
⚙️ Key MATLAB Functions:
wavedec2waverec2psnrcoder.configcodegen
📊 Expected Output & Metrics: PSNR vs bit-rate curves (bpp), DSP execution cycle benchmarks, compressed frame buffer size, and reconstructed image fidelity.
I = im2double(imread('aerial_recon.png'));
[C, S] = wavedec2(I, 3, 'bior4.4');
step_size = 0.08;
C_quant = sign(C) .* floor(abs(C) / step_size);
C_dequant = C_quant * step_size;
I_recon = waverec2(C_dequant, S, 'bior4.4');
disp(['Hardware Wavelet PSNR: ', num2str(psnr(I_recon, I)), ' dB']);
Est. Duration: 3–4 Weeks
Request Custom Project →
23. Automated Industrial Vision Inspection System for Defect Detection
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Develop an automated factory machine vision pipeline to measure manufactured part dimensions with sub-millimeter precision, detect surface scratches/voids, and trigger Pass/Fail actuator commands.
⚙️ Key MATLAB Functions:
regionpropsbwboundariesimfindcirclesedgeimprofile
📊 Expected Output & Metrics: Measured part physical dimensions (mm), defect bounding box overlays, inspection throughput (>20 parts/sec), and sorting accuracy (>99%).
part_img = imread('machined_gear.png');
gray = rgb2gray(part_img);
[centers, radii] = imfindcircles(gray, [20 80], 'Sensitivity', 0.92);
BW_defect = edge(gray, 'Canny', [0.15 0.35]);
defect_stats = regionprops(BW_defect, 'Area');
defect_area = sum([defect_stats.Area]);
if isempty(radii) || defect_area > 50
status = 'REJECT - Defect Detected';
else
status = 'PASS - Within Tolerance';
end
disp(['Part Status: ', status]);
Est. Duration: 1–2 Weeks
Request Custom Project →
24. Hands-Free Gesture-Controlled Image Slider via Optical Flow
Beginner
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Track real-time hand swipe motions in live webcam streams using Lucas-Kanade optical flow vector integration to switch photo slideshows and presentation slides hands-free.
⚙️ Key MATLAB Functions:
opticalFlowLKestimateFlowreadFrameuifigureuiimage
📊 Expected Output & Metrics: Real-time optical flow velocity field, horizontal gesture classification (left/right swipe), GUI image transitions, and response latency (<80ms).
opticFlow = opticalFlowLK('NoiseThreshold', 0.009);
cam = webcam; current_slide = 1;
while true
frame = rgb2gray(snapshot(cam));
flow = estimateFlow(opticFlow, frame);
mean_Vx = mean(flow.Vx(:));
if mean_Vx > 3.0
current_slide = current_slide + 1;
disp(['Swiped Next Slide -> ', num2str(current_slide)]);
elseif mean_Vx < -3.0
current_slide = max(1, current_slide - 1);
disp(['Swiped Prev Slide <- ', num2str(current_slide)]);
end
end
Est. Duration: 4–6 Hours
Request Custom Project →
25. Gabor Filter Bank Design for Fingerprint Ridge Enhancement
Advanced
Toolbox: Image Processing, Signal Processing
Deliverables: Code .m, Report
🎯 Problem & Objective: Enhance degraded fingerprint scans by tuning 2D Gabor filter orientation banks across 8 angles to reinforce ridge-valley clarity, extracting minutiae points prior to Verilog HDL hardware synthesis.
⚙️ Key MATLAB Functions:
gaborimgaborfiltbwmorphimfilteratan2
📊 Expected Output & Metrics: Enhanced ridge map visualizations, minutiae point coordinates (ridge endings/bifurcations), ridge frequency estimates, and Verilog testbench correlation.
wavelength = 8;
orientations = 0:22.5:157.5;
gaborArray = gabor(wavelength, orientations);
fp = im2double(imread('noisy_fingerprint.tif'));
[mag, ~] = imgaborfilt(fp, gaborArray);
enhanced_fp = max(mag, [], 3);
BW_ridge = imbinarize(enhanced_fp, graythresh(enhanced_fp));
skeleton = bwmorph(BW_ridge, 'thin', Inf);
figure; imshow(skeleton); title('Enhanced Fingerprint Ridge Skeleton');
Est. Duration: 2–3 Weeks
Request Custom Project →
26. Smart Farm: Automated Tomato Grading & Sorting Using Fuzzy Logic
Intermediate
Toolbox: Image Processing, Fuzzy Logic
Deliverables: Code .m, Report
🎯 Problem & Objective: Classify tomato physical quality (defect-free vs damaged) and ripeness stages (unripe, ripe, overripe) using HSV color metrics, surface spot area, and Mamdani Fuzzy Inference System (FIS) rules.
⚙️ Key MATLAB Functions:
rgb2hsvmamfisevalfisregionpropsaddRule
📊 Expected Output & Metrics: Fuzzy membership function surface plots, tomato grading label predictions, classification accuracy (>93%), and sorting decision speed.
tomato = imread('tomato_sample.jpg');
hsv = rgb2hsv(tomato);
mean_hue = mean(mean(hsv(:,:,1)));
mean_sat = mean(mean(hsv(:,:,2)));
fis = mamfis('Name', 'TomatoGrader');
fis = addInput(fis, [0 1], 'Name', 'Hue');
fis = addInput(fis, [0 1], 'Name', 'Saturation');
fis = addOutput(fis, [0 100], 'Name', 'RipenessScore');
ripeness = evalfis(fis, [mean_hue, mean_sat]);
disp(['Assigned Tomato Ripeness Index: ', num2str(ripeness), '/100']);
Est. Duration: 1–2 Weeks
Request Custom Project →
27. Automated Vegetable Leaf Recognition Using Shape Descriptors & GLCM
Intermediate
Toolbox: Image Processing, Computer Vision
Deliverables: Code .m, Report
🎯 Problem & Objective: Identify vegetable crop species from digital leaf photos by extracting shape descriptors (aspect ratio, eccentricity, solidity) and Gray-Level Co-occurrence Matrix (GLCM) texture metrics for KNN classification.
⚙️ Key MATLAB Functions:
regionpropsgraycomatrixgraycopropsfitcknnconfusionchart
📊 Expected Output & Metrics: Segmented leaf contour plots, GLCM texture feature vector tables, classification confusion matrices, and species identification accuracy (>95%).
leaf = imread('spinach_leaf.jpg');
BW = ~imbinarize(rgb2gray(leaf));
stats = regionprops(BW, 'Eccentricity', 'Solidity', 'Perimeter', 'Area');
form_factor = (4 * pi * stats.Area) / (stats.Perimeter^2);
glcm = graycomatrix(rgb2gray(leaf));
tex = graycoprops(glcm, {'Contrast', 'Energy', 'Homogeneity'});
feature_vector = [stats.Eccentricity, stats.Solidity, form_factor, tex.Contrast, tex.Homogeneity];
species_label = predict(trained_leaf_knn, feature_vector);
Est. Duration: 1–2 Weeks
Request Custom Project →