Matlab Process Images

try
    sam = segmentAnythingModel;  % Verifies support package and required add-on are available
    hasSAM = true;
catch
    hasSAM = false;  % Help the user install the support package
end

sam = segmentAnythingModel;              % Uses "sam2-large" by default
embeddings = extractEmbeddings(sam, I);  % Expensive — do ONCE per image

% Single foreground point — [x, y] coordinates on the object
masks = segmentObjectsFromEmbeddings(sam, embeddings, size(I), ...
    ForegroundPoints=[200 150]);

% Refine with background points
masks = segmentObjectsFromEmbeddings(sam, embeddings, size(I), ...
    ForegroundPoints=[200 150], BackgroundPoints=[50 50; 350 350]);

% [x, y, width, height]
masks = segmentObjectsFromEmbeddings(sam, embeddings, size(I), ...
    BoundingBox=[50 80 200 180]);

% Extract embeddings once, segment multiple times
embeddings = extractEmbeddings(sam, I);

mask1 = segmentObjectsFromEmbeddings(sam, embeddings, size(I), ...
    ForegroundPoints=[100 200]);
mask2 = segmentObjectsFromEmbeddings(sam, embeddings, size(I), ...
    BoundingBox=[300 100 150 200]);

[L, N] = superpixels(I, 500);    % REQUIRED before grabcut
ROI = false(size(I,1), size(I,2));
ROI(50:300, 100:350) = true;
BW = grabcut(I, L, ROI);

[L, N] = superpixels(I, 500);    % REQUIRED before lazysnapping
BW = lazysnapping(I, L, fgScribble, bgScribble);

L = imseggeodesic(RGB, scribble1, scribble2);           % 2 regions
L = imseggeodesic(RGB, scribble1, scribble2, scribble3); % 3 regions

BW = grayconnected(I, row, col, 20);  % tolerance is positional (not a Name-Value pair)

% R2026b: restrict to 4-connected pixels (horizontal/vertical only)
BW = grayconnected(I, row, col, 20, Connectivity=4);

% From rough threshold + dilate (most common)
mask = imbinarize(I);
mask = imdilate(mask, strel("disk", 10));
BW = activecontour(I, mask, 200, "Chan-Vese");

% From bounding rectangle
mask = false(size(I));
mask(r1:r2, c1:c2) = true;
BW = activecontour(I, mask, 200, "edge");

% Weight from intensity difference to seed
% graydiffweight and imsegfmm take (C, R) order — column first, then row
W = graydiffweight(I, col, row, GrayDifferenceCutoff=25);
BW = imsegfmm(W, col, row, 0.01);  % threshold on travel time

% Weight from gradient magnitude
W = gradientweight(I);
BW = imsegfmm(W, seedMask, 0.01);

classdef SAMSegmenter < matlab.ui.componentcontainer.ComponentContainer
    properties
        Image
        Mask
        SavedMask
        SegmentationAlpha = 0.5
    end
    properties (Access = private)
        Model           % segmentAnythingModel object
        Embeddings      % Extracted once per image
        Viewer          % images.ui.graphics.Viewer
        ImageObject     % Image displayed in viewer
        Bbox            % Current bounding box
        SegmentRequired % Flag to trigger update
        CurrentLabelID = 1
        IsForegroundMode = true
    end
    methods (Access = protected)
        function setup(comp)
            comp.Viewer = viewer2d(comp);
            comp.ImageObject = imageshow([], Parent=comp.Viewer);
            comp.Viewer.AnnotationAddedFcn = @(~,evt) annotationAdded(comp, evt);
        end
    end
end

% 1. Load image and extract embeddings ONCE
function loadImage(comp, imageData)
    comp.Image = imageData;
    comp.Model = segmentAnythingModel("sam2-large");
    comp.Embeddings = extractEmbeddings(comp.Model, imageData);
    comp.ImageObject.Data = imageData;
    comp.SavedMask = zeros(size(imageData, [1 2]), "uint8");
end

function update(comp)
    if ~comp.SegmentRequired, return; end
    comp.SegmentRequired = false;

    imageSize = size(comp.ImageObject.Data);
    annotations = comp.Viewer.Annotations;

    % Collect foreground/background points from annotations
    foreground = [];
    background = [];
    for idx = 1:numel(annotations)
        if isa(annotations(idx), "images.ui.graphics.roi.Point") && isvalid(annotations(idx))
            if annotations(idx).UserData  % true = foreground
                foreground(end+1,:) = annotations(idx).Position(1:2);
            else
                background(end+1,:) = annotations(idx).Position(1:2);
            end
        end
    end

    if isempty(foreground) && isempty(comp.Bbox), return; end

    % Segment using current prompts
    mask = segmentObjectsFromEmbeddings(comp.Model, comp.Embeddings, imageSize, ...
        ForegroundPoints=foreground, BoundingBox=comp.Bbox, BackgroundPoints=background);

    % Preview: overlay new mask on saved mask
    priorMask = comp.SavedMask;
    priorMask(mask) = uint8(comp.CurrentLabelID);
    comp.ImageObject.OverlayData = priorMask;
end

function annotationAdded(comp, event)
    event.Annotation.Interactions = "click";

    if isa(event.Annotation, "images.ui.graphics.roi.Rectangle")
        % Bounding box drawn — save position, switch to point mode
        comp.Bbox = event.Annotation.Position;
        comp.Viewer.Mode.Annotate.Style = "point";
        comp.Viewer.Mode.Annotate.ContinueAnnotating = true;
        comp.Viewer.Mode.CurrentMode = "annotate";
    else
        % Point — validate it's inside bounding box
        if ~isempty(comp.Bbox)
            pos = event.Annotation.Position;
            if pos(1) < comp.Bbox(1) || pos(2) < comp.Bbox(2) || ...
                    pos(1) > (comp.Bbox(1)+comp.Bbox(3)) || pos(2) > (comp.Bbox(2)+comp.Bbox(4))
                delete(event.Annotation);
                return;
            end
        end
        event.Annotation.UserData = comp.IsForegroundMode;
    end
    comp.SegmentRequired = true;
end

% Commit current preview to saved mask
function saveMask(comp)
    comp.SavedMask = comp.ImageObject.OverlayData;
    comp.Mask = comp.SavedMask;
    comp.Viewer.Annotations = [];
    comp.Bbox = [];
end

% Revert to last saved state
function clearAll(comp)
    comp.Viewer.Annotations = [];
    comp.ImageObject.OverlayData = comp.SavedMask;
    comp.Bbox = [];
end

function startupFcn(app)
    app.SamSegmenter = SAMSegmenter(app.WorkingAreaGrid);
end

function loadImageFromFile(app)
    [file, location] = uigetfile("*.*", "Select an image");
    if ~isequal(file, 0)
        d = uiprogressdlg(app.UIFigure, Title="Please Wait", ...
            Message="Generating SAM embeddings...", Indeterminate="on");
        imageData = imread(fullfile(location, file));
        loadImage(app.SamSegmenter, imageData);
        close(d);
    end
end

function exportMask(app)
    mask = app.SamSegmenter.Mask;
    assignin("base", "SegmentedImage", mask);
end

% Direct overlay display (preferred — one step, interactive)
imageshow(I, OverlayData=BW);

% For generating an RGB array (e.g., saving to file or further processing)
rgb = labeloverlay(I, BW, Transparency=0.5);