Add files via upload

Author: viakkala

+helper/dist2bbox.m

@@ -0,0 +1,19 @@
+function boxesXYWH = dist2bbox(distance,anchorGrid)
+% Transform distance(ltrb) to box(xywh or xyxy)
+
+xywh = true;
+dim=1;
+
+% matrix divided into two along dim 1
+rb = distance(3:end,:);
+lt = distance(1:2,:);
+x1y1 = anchorGrid - lt;
+x2y2 = anchorGrid + rb;
+
+if xywh
+    cxy = (x1y1 + x2y2) ./ 2;
+    wh = x2y2 - x1y1;
+end
+
+boxesXYWH = vertcat(cxy, wh);  % xywh bbox
+end

+helper/distributionFocalLoss.m

@@ -0,0 +1,56 @@
+function boxes = distributionFocalLoss(boxes)
+% Distribution Focal Loss Module
+
+sz = size(boxes);
+c1=16; % pre-specified
+
+% compute batch. channel and anchors
+if size(sz,2)>2
+    batch=sz(3);
+else
+    batch = 1;
+end
+ch = sz(1);
+anchors = sz(2);
+
+% Reshape Operation
+boxes = permute(boxes,[2,1,3,4]); % 1 d qual like python
+boxes = reshape(boxes,anchors,c1,4,batch);
+boxes = permute(boxes,[2,1,3,4]);
+
+% Transpose Operation
+boxes = permute(boxes,[3,2,1,4]);
+
+% softmax along the channel dimension
+boxes = softmax(dlarray(boxes,'SSC'));  % produces a diff of 10^-3
+boxes = extractdata(boxes);
+
+% 1-d conv operation
+% Define weights
+weights = [0:c1-1];
+m = size(boxes,1);
+n = size(boxes,2);
+weights = reshape(repmat(weights,m*n,1),m,n,[]);
+% Conv operation
+boxes = boxes .* weights;
+boxes = sum(boxes,3);   % diff of 10^-2 because of above diff
+
+% Reshape Operation
+boxes = permute(boxes,[2,1,3,4]);
+boxes = reshape(boxes,anchors,4,batch);
+boxes = permute(boxes,[2,1,3,4]);
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+

+helper/extractDetections.m

@@ -0,0 +1,32 @@
+function [bboxes,scores,labelIds] = extractDetections(predictions,numClasses,confThreshold)
+
+% Filter predictions by confidence threshold 
+xc = max(predictions(5:end,:),[],1) > confThreshold; % candidates for each image
+
+% TODO: Hardcoding now only one image 
+% INDEXING REQUIRED if multiple images 
+pred = predictions';
+pred = pred(xc(1,:),:);
+
+% box, class
+box = pred(:,1:4);
+cls = pred(:,5:4+numClasses);
+
+% convert [x_c y_c w h] to [xTopLeft yTopLeft w h]
+bboxesTopLeft = iConvertCenterToTopLeft(box); 
+[classProbs, classIdx] = max(cls,[],2);
+scorePred = classProbs;
+classPred = classIdx;
+
+% NMS 
+[bboxes, scores, labelIds] = selectStrongestBboxMulticlass(bboxesTopLeft, scorePred, classPred ,...
+     'RatioType', 'Union', 'OverlapThreshold', 0.45);
+end
+
+
+function bboxes = iConvertCenterToTopLeft(bboxes)
+bboxes(:,1) = bboxes(:,1)- bboxes(:,3)/2 + 0.5; 
+bboxes(:,2) = bboxes(:,2)- bboxes(:,4)/2 + 0.5;
+bboxes = floor(bboxes);
+bboxes(bboxes<1)=1; 
+end

+helper/getCOCOClassNames.m

@@ -0,0 +1,86 @@
+function classNames = getCOCOClassNames()
+% getCOCOClassNames function returns the names of COCO dataset classes.
+
+% Copyright 2023 The MathWorks, Inc.
+
+classNames={'person'
+'bicycle'
+'car'
+'motorbike'
+'aeroplane'
+'bus'
+'train'
+'truck'
+'boat'
+'traffic light'
+'fire hydrant'
+'stop sign'
+'parking meter'
+'bench'
+'bird'
+'cat'
+'dog'
+'horse'
+'sheep'
+'cow'
+'elephant'
+'bear'
+'zebra'
+'giraffe'
+'backpack'
+'umbrella'
+'handbag'
+'tie'
+'suitcase'
+'frisbee'
+'skis'
+'snowboard'
+'sports ball'
+'kite'
+'baseball bat'
+'baseball glove'
+'skateboard'
+'surfboard'
+'tennis racket'
+'bottle'
+'wine glass'
+'cup'
+'fork'
+'knife'
+'spoon'
+'bowl'
+'banana'
+'apple'
+'sandwich'
+'orange'
+'broccoli'
+'carrot'
+'hot dog'
+'pizza'
+'donut'
+'cake'
+'chair'
+'sofa'
+'pottedplant'
+'bed'
+'diningtable'
+'toilet'
+'tvmonitor'
+'laptop'
+'mouse'
+'remote'
+'keyboard'
+'cell phone'
+'microwave'
+'oven'
+'toaster'
+'sink'
+'refrigerator'
+'book'
+'clock'
+'vase'
+'scissors'
+'teddy bear'
+'hair drier'
+'toothbrush'};
+end

+helper/make_anchors.m

@@ -0,0 +1,28 @@
+function [anchorGrid, stride] = make_anchors(feats, strideValues)
+% feats - cell array containing output features 
+% gridCellOffset = 0.5 - value to shift the z,y values by 
+
+gridCellOffset = 0.5; 
+n = 3;
+anchorGridTmp = cell(n,1);
+strideTmp = cell(n,1);
+totalSize = 0;
+
+for i = 1:n
+    sz = size(feats{i});
+    totalSize = totalSize + (sz(1).*sz(2));
+    anchorGridTmp{i,1} = coder.nullcopy(zeros(sz(1).*sz(2),2));
+    strideTmp{i,1} = coder.nullcopy(zeros(sz(1).*sz(2),2));
+end
+
+for i=1:size(strideValues,2)
+    [h,w,~,~]= size(feats{i});
+    sx = (0:w-1)+gridCellOffset;
+    sy = (0:h-1)+gridCellOffset;
+    [sy,sx]= meshgrid(sy,sx);
+    anchorGridTmp{i,1} = cat(2, sx(:), sy(:));
+    strideTmp{i,1} = repmat(strideValues(i),h*w,1);
+end
+anchorGrid = cat(1,anchorGridTmp{:});
+stride = cat(1,strideTmp{:});
+end

+helper/per.m

@@ -0,0 +1,8 @@
+function op = per(op)
+if size(size(op),2)==4
+op = permute(op,[3,4,2,1]);
+
+else
+op = permute(op,[2,3,1]);
+end
+end

+helper/postProcessYOLOv8.m

@@ -0,0 +1,19 @@
+
+function newCoords = postProcessYOLOv8(img1_shape,coords,img0_shape)
+
+% Rescale coords (xyxy) from img1_shape to img0_shape
+gain = min(img1_shape(1) / img0_shape(1), img1_shape(2) / img0_shape(2));  
+pad = coder.nullcopy(zeros(1,2));
+pad(1) = (img1_shape(2) - img0_shape(2) * gain)./ 2;
+pad(2) = (img1_shape(1) - img0_shape(1) * gain)./ 2; 
+
+newCoords = coords - repmat(pad,size(coords,1),2);
+newCoords = newCoords./gain;
+newCoords(newCoords<0) = 0.1;
+
+newCoords(:,1) = min(newCoords(:,1),img0_shape(2));
+newCoords(:,2) = min(newCoords(:,2),img0_shape(1));
+newCoords(:,3) = min(newCoords(:,3),img0_shape(2));
+newCoords(:,4) = min(newCoords(:,4),img0_shape(1));
+
+end

+helper/postprocess.m

@@ -0,0 +1,38 @@
+function [bboxes,scores,labelIds] = postprocess(outFeatureMaps, origSize, newSize, numClasses)
+% The postprocess function applies postprocessing on the generated feature
+% maps and returns bounding boxes, detection scores and labels.
+
+% Copyright 2024 The MathWorks, Inc.
+
+% Transform outFeatureMaps to box [x_center y_center w h] and class scores
+[box cls] = helper.yolov8Transform(outFeatureMaps, numClasses);
+
+% Map network predictions to anchor girds.
+predictions = cat(1, box, cls);
+confThreshold = 0.5;
+
+% Extract detections from predictions.
+[bboxesPred,scores,labelIds] = helper.extractDetections(predictions, numClasses, confThreshold);
+bboxesTmp = xywhToX1Y1X2Y2(bboxesPred);
+
+% Map predictions back to original dimension.
+bboxesPost = helper.postProcessYOLOv8(newSize, bboxesTmp, origSize);
+bboxes = x1y1x2y2ToXYWH(bboxesPost);
+
+end
+
+function boxes = xywhToX1Y1X2Y2(boxes)
+% Convert [x y w h] box to [x1 y1 x2 y2]. Input and output
+% boxes are in pixel coordinates. boxes is an M-by-4
+% matrix.
+boxes(:,3) = boxes(:,1) + boxes(:,3) - 1;
+boxes(:,4) = boxes(:,2) + boxes(:,4) - 1;
+end
+
+function boxes = x1y1x2y2ToXYWH(boxes)
+% Convert [x1 y1 x2 y2] boxes into [x y w h] format. Input and
+% output boxes are in pixel coordinates. boxes is an M-by-4
+% matrix.
+boxes(:,3) = boxes(:,3) - boxes(:,1) + 1;
+boxes(:,4) = boxes(:,4) - boxes(:,2) + 1;
+end

+helper/preprocess.m

@@ -0,0 +1,38 @@
+function output = preprocess(img,targetSize)
+% This function preprocesses the input image.
+
+% Copyright 2024 The MathWorks, Inc.
+
+imgSize = size(img,1:2);
+
+% Compute scaling ratio
+scaleRatio = min(targetSize(1)./ imgSize(1), targetSize(2) / imgSize(2));
+padSize = [round(imgSize(1) * scaleRatio), round(imgSize(2) * scaleRatio)];
+
+% Compute padding values
+dw = targetSize(1) - padSize(2);  % w padding
+dw = mod(dw, 32);                 % w padding
+dw = dw./2;                       % divide padding into 2 sides
+
+dh = targetSize(2) - padSize(1);  % h padding
+dh = mod(dh, 32);                 % h padding
+dh = dh./2;                       % divide padding into 2 sides
+
+% Resize input image
+I = imresize(img, padSize,'bilinear',Antialiasing = false);
+
+% Pad values to the image
+top     = round(dh - 0.1);
+bottom  = round(dh + 0.1);
+left    = round(dw - 0.1);
+right   = round(dw + 0.1);
+
+I = padarray(I,[top left],114,'pre');
+I = padarray(I,[bottom,right],114,'post');
+
+% Convert uint8 to single
+I = single(I);
+
+% Rescale image pixes to [0,1]
+output = I./255;
+end

+helper/yolov8Transform.m

@@ -0,0 +1,40 @@
+function [box, cls] = yolov8Transform(predictions,numClasses)
+% Transforms predictions from dlnetwork to
+% box [x_center y_center w h] and cls scores
+
+regMax = 16;
+outputsPerAnchor = numClasses + regMax*4;
+stride = [8,16,32];
+batch = 1;
+
+% Extract feature maps from Matlab model
+% Apply this if dlarray output
+predictions = cellfun(@extractdata,predictions,'UniformOutput',false);
+predictions = cellfun(@gather,predictions,'UniformOutput',false);
+
+% Compute anchor grid and stride
+[anchorGrid, stride] = helper.make_anchors(predictions, stride);
+% anchor grid and stride transposed
+anchorGrid = anchorGrid';
+stride = stride';
+
+% Reshape predictions from model output
+pred = cellfun(@(p){permute(p,[2,1,3,4])}, predictions, 'UniformOutput',true);
+pred = cellfun(@(p){reshape(p,[],outputsPerAnchor, batch)}, pred, 'UniformOutput',true);
+pred = cellfun(@(p){permute(p,[2,1,3,4])}, pred, 'UniformOutput',true);
+
+% Concat all Predictions
+predCat = cat(2,pred{:});
+
+% Split classes and boxes
+box = predCat(1:64,:,:);
+cls = predCat(65:end,:,:);
+
+box = helper.distributionFocalLoss(box);
+% Converting boxes to xywh format here
+box = helper.dist2bbox(box,anchorGrid);
+box = box .* stride;
+% Sigmoid of classes
+cls = sigmoid(dlarray(cls));
+cls = extractdata(cls);
+end