Face Recognition MATLAB Projects (15+ Ideas with Complete Code)

% 1. Load Synced IR and Depth Frames from Kinect V2
irImg = imread('kinect_ir_sample.png');       % 512x424 16-bit IR
depthMap = load('kinect_depth_sample.mat').depth; % Depth in mm (500-4500mm)

% 2. Range Gating: Isolate User Head in Depth Plane (0.6m to 1.2m)
headMask = depthMap >= 600 & depthMap <= 1200;
irFiltered = mat2gray(irImg) .* double(headMask);

% 3. Detect Face Region using Cascade Detector on IR
faceDetector = vision.CascadeObjectDetector('FrontalFaceCART');
faceBBox = faceDetector(uint8(irFiltered * 255));

if ~isempty(faceBBox)
    % 4. Locate Nose Tip (Minimum Depth in Face ROI)
    faceDepth = depthMap(faceBBox(1,2):faceBBox(1,2)+faceBBox(1,4), ...
                         faceBBox(1,1):faceBBox(1,1)+faceBBox(1,3));
    [minDepth, minIdx] = min(faceDepth(:));
    [noseY, noseX] = ind2sub(size(faceDepth), minIdx);
    
    % 5. Estimate Lip ROI Bounding Box Relative to Nose Point
    lipY = faceBBox(1,2) + noseY + round(0.18 * faceBBox(1,4));
    lipX = faceBBox(1,1) + noseX - round(0.20 * faceBBox(1,3));
    lipW = round(0.40 * faceBBox(1,3)); lipH = round(0.22 * faceBBox(1,4));
    
    % 6. Annotate & Display
    outImg = insertObjectAnnotation(irFiltered, 'rectangle', [lipX, lipY, lipW, lipH], 'Lip ROI');
    figure; imshow(outImg); title('Depth-Constrained Lip Localization');
end

% 1. Design Multi-Orientation Gabor Filter Bank
wavelengths = [4 8 16];
orientations = [0 45 90 135];
gaborBank = gabor(wavelengths, orientations);

% 2. Load Grayscale Face Image
I = imread('face_unconstrained.jpg');
if size(I,3) == 3, I = rgb2gray(I); end

% 3. Compute Gabor Magnitude & Phase Responses
[mag, phase] = imgaborfilt(I, gaborBank);

% 4. Aggregate Horizontal & Diagonal Energy for Lip Cavity
mouthEnergy = sum(mag(:,:,[1, 2, 4]), 3);
mouthEnergy = mat2gray(mouthEnergy);

% 5. Morphological Thresholding for Lip Saliency
bwMouth = imbinarize(mouthEnergy, 'adaptive', 'Sensitivity', 0.55);
stats = regionprops(bwMouth, 'Area', 'BoundingBox', 'Centroid');

figure;
subplot(1,2,1); imshow(I); title('Original Input Face');
subplot(1,2,2); imshow(mouthEnergy, []); colormap('jet'); colorbar;
title('Gabor Energy Saliency Map');

% 1. Read RGB Image and Convert to Color Spaces
rgb = imread('portrait_sample.jpg');
hsv = rgb2hsv(rgb);
ycbcr = rgb2ycbcr(rgb);

H = hsv(:,:,1); S = hsv(:,:,2); V = hsv(:,:,3);
Cb = double(ycbcr(:,:,2)); Cr = double(ycbcr(:,:,3));

% 2. Skin Segmentation via Empirical Thresholds
skinMask = (H >= 0.0 & H <= 0.15) & (S >= 0.23 & S <= 0.68) & (V >= 0.35);
skinMask = imclose(skinMask, strel('disk', 5));
skinMask = imfill(skinMask, 'holes');

% 3. Lip Chrominance Map Construction (Cr^2 - Cr/Cb)
lipMap = (Cr.^2) .* ((Cr.^2) - 1.2 * (Cr ./ (Cb + eps)));
lipMap = mat2gray(lipMap) .* skinMask;

% 4. Binarize Lip Region in Face Area
lipBW = lipMap > 0.45;
stats = regionprops(lipBW, 'BoundingBox', 'Area');

figure;
subplot(1,3,1); imshow(rgb); title('Input Image');
subplot(1,3,2); imshow(skinMask); title('Skin Binary Mask');
subplot(1,3,3); imshow(lipMap, []); title('Lip Chrominance Map');

% 1. Define Camera Intrinsic Calibration Matrix & Distortion Model
focalLength = [450, 450];      % Effective focal length [fx, fy]
principalPoint = [320, 240];   % Optical center [cx, cy]
radialDistortion = [-0.18, 0.04]; % Barrel/Pincushion coefficients

camParams = cameraParameters('IntrinsicMatrix', [focalLength(1) 0 0; 0 focalLength(2) 0; principalPoint 1], ...
                             'RadialDistortion', radialDistortion);

% 2. Undistort Wide-Angle Selfie Video Frame
rawFrame = imread('distorted_face.jpg');
correctedFrame = undistortImage(rawFrame, camParams);

% 3. Initialize KLT Modular Facial Feature Point Tracker
pointTracker = vision.PointTracker('MaxBidirectionalError', 2);
points = detectFASTFeatures(rgb2gray(correctedFrame), 'MinContrast', 0.15);
initialize(pointTracker, points.Location, correctedFrame);

% 4. Track Points on Next Video Frame
[trackedPoints, isFound] = pointTracker(correctedFrame);

figure; imshow(correctedFrame); hold on;
plot(trackedPoints(isFound,1), trackedPoints(isFound,2), 'g+', 'LineWidth', 2);
title('Perspective Corrected Frame with KLT Point Tracking');

% 1. Initialize Multi-Stage Cascade Object Detectors
faceDetector = vision.CascadeObjectDetector('FrontalFaceCART', 'MinSize', [40 40]);
eyeDetector = vision.CascadeObjectDetector('EyePairBig');
mouthDetector = vision.CascadeObjectDetector('Mouth');

% 2. Load Input Test Image
img = imread('group_faces.jpg');

% 3. Detect Faces using Fast Integral Image Processing
faceBBoxes = faceDetector(img);

% 4. Annotate Detected Faces & Sub-Features
annotatedImg = insertObjectAnnotation(img, 'rectangle', faceBBoxes, 'Face', ...
    'LineWidth', 3, 'Color', 'cyan', 'TextColor', 'black');

% 5. Display Count & Visual Results
fprintf('Detected %d human faces successfully.\n', size(faceBBoxes, 1));
figure; imshow(annotatedImg);
title(sprintf('Viola-Jones Detection: %d Faces Found', size(faceBBoxes, 1)));

% 1. Synthesize Database of 50,000 512-D Face Embeddings
numEnrolled = 50000;
featureDim = 512;
dbEmbeddings = normc(randn(numEnrolled, featureDim, 'single'));
probeVector = normc(randn(1, featureDim, 'single'));

% 2. Transfer Vectors to CUDA GPU Memory
gpuDB = gpuArray(dbEmbeddings);
gpuProbe = gpuArray(probeVector);

% 3. Compute High-Speed Matrix-Vector Cosine Similarity
tic;
similarityScores = gpuDB * gpuProbe'; % 50000x1 inner product on GPU cores
[topScores, topIndices] = maxk(similarityScores, 5);
gpuTime = toc;

% 4. Retrieve Results to Host Memory
topScores = gather(topScores);
topIndices = gather(topIndices);

fprintf('GPU Matching Complete in: %.4f ms across %d identities.\n', gpuTime*1000, numEnrolled);
fprintf('Top Match Candidate Index: #%d (Score: %.4f)\n', topIndices(1), topScores(1));

% 1. Load Canonical Face Image
img = imread('face_sample.jpg');
[H, W, ~] = size(img);

% 2. Generate Central Scotoma Gaussian Blind Spot Mask
[X, Y] = meshgrid(1:W, 1:H);
centerX = W/2; centerY = H/2 + 10;
scotomaRadius = 55;
scotomaMask = exp(-((X - centerX).^2 + (Y - centerY).^2) / (2 * scotomaRadius^2));

% 3. Apply Simulated Central Vision Loss
cvlSimulated = double(rgb2gray(img)) .* (1 - scotomaMask);

% 4. Extract External Feature Ring (Hairline, Jaw, Ears)
outerMask = (X - centerX).^2 + (Y - centerY).^2 > (1.3 * scotomaRadius)^2;
externalFeatures = cvlSimulated .* outerMask;

figure;
subplot(1,2,1); imshow(uint8(cvlSimulated)); title('Simulated Central Scotoma (CVL)');
subplot(1,2,2); imshow(uint8(externalFeatures)); title('Isolated External Salient Features');

% 1. Load Pretrained Backbone & Construct LayerGraph
net = resnet50;
lgraph = layerGraph(net);

% 2. Replace Final Fully Connected Layers for ArcFace Embedding
numIdentities = 100;
newLayers = [
    fullyConnectedLayer(512, 'Name', 'fc_embedding', 'WeightLearnRateFactor', 10)
    batchNormalizationLayer('Name', 'bn_embedding')
    fullyConnectedLayer(numIdentities, 'Name', 'fc_arcface')
    softmaxLayer('Name', 'softmax')
    classificationLayer('Name', 'output')
];

lgraph = replaceLayer(lgraph, 'fc1000', newLayers(1));
lgraph = addLayers(lgraph, newLayers(2:end));
lgraph = connectLayers(lgraph, 'fc_embedding', 'bn_embedding');

% 3. Specify Training Options with Cosine Annealing
options = trainingOptions('adam', ...
    'InitialLearnRate', 1e-4, ...
    'MaxEpochs', 20, ...
    'MiniBatchSize', 32, ...
    'Shuffle', 'every-epoch', ...
    'Plots', 'training-progress', ...
    'Verbose', false);

% [trainedNet, info] = trainNetwork(imdsTrain, lgraph, options);

% 1. Establish Serial Port Communication with Microcontroller
s = serialport("COM4", 9600, "Timeout", 10);
configureTerminator(s, "CR/LF");
flush(s);

% 2. Connect to Dashboard USB Camera
cam = webcam(1);
disp("Automotive Security Online. Waiting for RFID Tag...");

% 3. Read RFID UID from Vehicle Keycard
rfidTag = readline(s);
validUID = "A4:3F:89:C2";

if contains(rfidTag, validUID)
    disp("RFID Verified. Initiating Driver Biometric Face Check...");
    img = snapshot(cam);
    
    % 4. Run MATLAB Biometric Face Recognition
    detector = vision.CascadeObjectDetector();
    bbox = detector(img);
    
    if ~isempty(bbox)
        % Verify Driver Identity (Similarity Check)
        writeline(s, "AUTH_SUCCESS_IGNITION_ON");
        disp("Access Granted: Ignition Enabled.");
    else
        writeline(s, "AUTH_FAIL_FACE_NOT_FOUND");
    end
else
    writeline(s, "AUTH_FAIL_INVALID_RFID");
end
clear cam; delete(s);

% 1. Extract 2D-DCT Low-Frequency Feature Vectors
numSamples = 200; featureLen = 64;
featureMatrix = zeros(featureLen, numSamples);

for i = 1:numSamples
    faceImg = im2double(imread(sprintf('orl_faces/s%d.pgm', i)));
    dctCoeffs = dct2(faceImg);
    % Extract top-left 8x8 zigzag low-frequency coefficients
    lowFreq = dctCoeffs(1:8, 1:8);
    featureMatrix(:, i) = lowFreq(:);
end

% 2. Configure 10x10 Hexagonal Self-Organizing Map
dimensions = [10 10];
net = selforgmap(dimensions);
net.trainParam.epochs = 150;

% 3. Train Neural Network on Extracted Feature Space
net = train(net, featureMatrix);

% 4. Visualize Neuron Clusters & Hits
y = net(featureMatrix);
figure; plotsomhits(net, featureMatrix);
title('SOM Neuron Cluster Activation Distribution');

% 1. Load Enrolled Database and Construct Data Matrix X (N x D)
% Assume X is (165 x 10000) for 15 subjects with 11 images each
[coeff, score, latent, tsquared, explained] = pca(X_train);

% 2. Retain Top-K Principal Components (95% Energy)
k = find(cumsum(explained) >= 95, 1);
eigenfaces = coeff(:, 1:k);

% 3. Project Training and Testing Faces into Subspace
projTrain = (X_train - mean(X_train)) * eigenfaces;
projTest = (X_test - mean(X_train)) * eigenfaces;

% 4. 1-Nearest Neighbor Euclidean Distance Classification
distMatrix = pdist2(projTest, projTrain, 'euclidean');
[minVal, minIdx] = min(distMatrix, [], 2);
predictedLabels = y_train(minIdx);

accuracy = mean(predictedLabels == y_test) * 100;
fprintf('Eigenfaces (PCA) Classification Accuracy: %.2f%%\n', accuracy);

% 1. Load Pretrained 68-Point Facial Landmark Detector
detector = vision.CascadeObjectDetector();
img = imread('pose_test_subject.jpg');
bbox = detector(img);

if ~isempty(bbox)
    % 2. Regress 68 2D Facial Keypoints
    landmarks = detectFacialLandmarks(img, bbox(1,:));
    
    % 3. Canonical 3D Generic Anthropometric Model Points (mm)
    modelPoints3D = [
        0.0,   0.0,   0.0;    % Nose tip (Landmark 31)
        0.0, -330.0, -65.0;    % Chin (Landmark 9)
      -225.0,  170.0, -135.0;  % Left eye left corner (Landmark 37)
       225.0,  170.0, -135.0;  % Right eye right corner (Landmark 46)
      -150.0, -150.0, -125.0;  % Left mouth corner (Landmark 49)
       150.0, -150.0, -125.0   % Right mouth corner (Landmark 55)
    ];
    
    % 4. Solve PnP Pose for Euler Angles (Pitch, Yaw, Roll)
    imagePoints2D = landmarks([31, 9, 37, 46, 49, 55], :);
    [R, t] = estimateWorldCameraPose(imagePoints2D, modelPoints3D, cameraIntrinsics([500 500],[320 240],[480 640]));
    eulAngles = rotm2eul(R.R, 'ZYX') * (180/pi);
    
    fprintf('Head Pose -> Yaw: %.2f deg, Pitch: %.2f deg, Roll: %.2f deg\n', eulAngles(1), eulAngles(2), eulAngles(3));
end

% 1. Preprocess Cropped Face ROI to Grayscale
faceCrop = imread('probe_face_crop.jpg');
if size(faceCrop, 3) == 3, faceGray = rgb2gray(faceCrop); end
faceGray = imresize(faceGray, [128 128]);

% 2. Extract Multi-Radius Uniform Local Binary Pattern (LBP) Descriptors
lbpRadius1 = extractLBPFeatures(faceGray, 'Radius', 1, 'NumNeighbors', 8, 'Upright', false);
lbpRadius2 = extractLBPFeatures(faceGray, 'Radius', 2, 'NumNeighbors', 16, 'Upright', false);

% 3. Compute 2D Fourier Frequency Energy Distribution
F = fftshift(fft2(double(faceGray)));
powerSpectrum = abs(F).^2;
highFreqEnergy = sum(powerSpectrum(:) > median(powerSpectrum(:)) * 10);

% 4. Concatenate Feature Descriptor Vector
livenessVector = [lbpRadius1, lbpRadius2, highFreqEnergy];

% 5. Predict via Pre-Trained Support Vector Machine
[predictedLabel, score] = predict(svmAntiSpoofModel, livenessVector);
fprintf('Liveness Classification: %s (Confidence: %.2f%%)\n', string(predictedLabel), max(score)*100);

% 1. Load Co-Registered RGB and LWIR Thermal Frames
rgbImg = imread('subject_rgb_masked.jpg');
thermalMatrix = load('thermal_raw_kelvin.mat').T_Celsius; % Calibrated matrix in °C

% 2. Detect Upper Face / Periocular Region (Top 45% of Face Box)
detector = vision.CascadeObjectDetector();
bbox = detector(rgbImg);
periocularBBox = [bbox(1,1), bbox(1,2), bbox(1,3), round(bbox(1,4)*0.45)];

% 3. Compute Peak Radiometric Temperature in Inner Canthus / Forehead
foreheadThermal = thermalMatrix(periocularBBox(2):periocularBBox(2)+periocularBBox(4), ...
                                periocularBBox(1):periocularBBox(1)+periocularBBox(3));
maxTemp = max(foreheadThermal(:));

% 4. Extract Deep Periocular Embeddings via MobileNetV2
periocularCrop = imresize(imcrop(rgbImg, periocularBBox), [224 224]);
features = activations(net, periocularCrop, 'global_average_pooling2d-default');

isFever = maxTemp > 37.8;
fprintf('Subject Core Temp: %.2f °C | Fever Alert: %s\n', maxTemp, string(isFever));

% 1. Define Temporal BiLSTM Architecture for 16-Frame Video Clips
numFeatures = 1000; % Feature vector size from CNN backbone
numHiddenUnits = 128;
numClasses = 7;     % 7 Emotional Classes

layers = [
    sequenceInputLayer(numFeatures, 'Name', 'seq_in')
    bilstmLayer(numHiddenUnits, 'OutputMode', 'last', 'Name', 'bilstm')
    dropoutLayer(0.4, 'Name', 'drop')
    fullyConnectedLayer(numClasses, 'Name', 'fc')
    softmaxLayer('Name', 'softmax')
    classificationLayer('Name', 'class_out')
];

% 2. Training Configurations
options = trainingOptions('adam', ...
    'MaxEpochs', 30, ...
    'MiniBatchSize', 16, ...
    'InitialLearnRate', 0.001, ...
    'GradientThreshold', 1, ...
    'Plots', 'training-progress');

% [trainedBiLSTM, info] = trainNetwork(X_seq_train, Y_train, layers, options);