added early exit from main loop for semistable final states

.gitignore

@@ -40,4 +40,11 @@ codegen/
 *.sbproj.bak
 
 # Sandbox contents
-sandbox/*
+sandbox/*
+
+# Videos
+*.mp4
+*.avi
+
+# Figures
+*.fig

@agent/agent.m

@@ -0,0 +1,40 @@
+classdef agent
+    properties (SetAccess = private, GetAccess = public)
+        % Identifiers
+        index = NaN;
+        label = "";
+
+        % Sensor
+        sensorModel;
+        sensingLength = 0.05; % length parameter used by sensing function
+
+        % Guidance
+        guidanceModel;
+
+        % State
+        lastPos = NaN(1, 3); % position from previous timestep
+        pos = NaN(1, 3); % current position
+        vel = NaN(1, 3); % current velocity
+        pan = NaN; % pan angle
+        tilt = NaN; % tilt angle
+
+        % Collision
+        collisionGeometry;
+
+        % FOV cone
+        fovGeometry;
+
+        % Communication
+        comRange = NaN;
+
+        % Plotting
+        scatterPoints;
+    end
+
+    methods (Access = public)
+        [obj] = initialize(obj, pos, vel, pan, tilt, collisionGeometry, sensorModel, guidanceModel, comRange, index, label);
+        [obj] = run(obj, sensingObjective, domain, partitioning);
+        [obj, f] = plot(obj, ind, f);
+        updatePlots(obj);
+    end
+end

@agent/initialize.m

@@ -0,0 +1,33 @@
+function obj = initialize(obj, pos, vel, pan, tilt, collisionGeometry, sensorModel, guidanceModel, comRange, index, label)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+        pos (1, 3) double;
+        vel (1, 3) double;
+        pan (1, 1) double;
+        tilt (1, 1) double;
+        collisionGeometry (1, 1) {mustBeGeometry};
+        sensorModel (1, 1) {mustBeSensor}
+        guidanceModel (1, 1) {mustBeA(guidanceModel, 'function_handle')};
+        comRange (1, 1) double = NaN;
+        index (1, 1) double = NaN;
+        label (1, 1) string = "";
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+    end
+
+    obj.pos = pos;
+    obj.vel = vel;
+    obj.pan = pan;
+    obj.tilt = tilt;
+    obj.collisionGeometry = collisionGeometry;
+    obj.sensorModel = sensorModel;
+    obj.guidanceModel = guidanceModel;
+    obj.comRange = comRange;
+    obj.index = index;
+    obj.label = label;
+
+    % Initialize FOV cone
+    obj.fovGeometry = cone;
+    obj.fovGeometry = obj.fovGeometry.initialize([obj.pos(1:2), 0], tand(obj.sensorModel.alphaTilt) * obj.pos(3), obj.pos(3), REGION_TYPE.FOV, sprintf("%s FOV", obj.label));
+end

@agent/plot.m

@@ -0,0 +1,35 @@
+function [obj, f] = plot(obj, ind, f)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+        ind (1, :) double = NaN;
+        f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+        f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
+    end
+
+    % Create axes if they don't already exist
+    f = firstPlotSetup(f);
+
+    % Plot points representing the agent position
+    hold(f.Children(1).Children(end), "on");
+    o = scatter3(f.Children(1).Children(end), obj.pos(1), obj.pos(2), obj.pos(3), 'filled', 'ko', 'SizeData', 25);
+    hold(f.Children(1).Children(end), "off");
+
+    % Check if this is a tiled layout figure
+    if strcmp(f.Children(1).Type, 'tiledlayout')
+        % Add to other perspectives
+        o = [o; copyobj(o(1), f.Children(1).Children(2))];
+        o = [o; copyobj(o(1), f.Children(1).Children(3))];
+        o = [o; copyobj(o(1), f.Children(1).Children(4))];
+    end
+
+    obj.scatterPoints = o;
+
+    % Plot collision geometry
+    [obj.collisionGeometry, f] = obj.collisionGeometry.plotWireframe(ind, f);
+
+    % Plot FOV geometry
+    [obj.fovGeometry, f] = obj.fovGeometry.plot(ind, f);
+end

@agent/run.m

@@ -0,0 +1,28 @@
+function obj = run(obj, sensingObjective, domain, partitioning)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+        sensingObjective (1, 1) {mustBeA(sensingObjective, 'sensingObjective')};
+        domain (1, 1) {mustBeGeometry};
+        partitioning (:, :) double;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+    end
+
+    % Do sensing
+    [sensedValues, sensedPositions] = obj.sensorModel.sense(obj, sensingObjective, domain, partitioning);
+
+    % Determine next planned position
+    nextPos = obj.guidanceModel(sensedValues, sensedPositions, obj.pos);
+
+    % Move to next position
+    % (dynamics not modeled at this time)
+    obj.lastPos = obj.pos;
+    obj.pos = nextPos;
+
+    % Calculate movement
+    d = obj.pos - obj.collisionGeometry.center;
+
+    % Reinitialize collision geometry in the new position
+    obj.collisionGeometry = obj.collisionGeometry.initialize([obj.collisionGeometry.minCorner; obj.collisionGeometry.maxCorner] + d, obj.collisionGeometry.tag, obj.collisionGeometry.label);
+end

@agent/updatePlots.m

@@ -0,0 +1,35 @@
+function updatePlots(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'agent')};
+    end
+    arguments (Output)
+    end
+
+    % Scatterplot point positions
+    for ii = 1:size(obj.scatterPoints, 1)
+        obj.scatterPoints(ii).XData = obj.pos(1);
+        obj.scatterPoints(ii).YData = obj.pos(2);
+        obj.scatterPoints(ii).ZData = obj.pos(3);
+    end
+
+    % Find change in agent position since last timestep
+    deltaPos = obj.pos - obj.lastPos;
+
+    % Collision geometry edges
+    for jj = 1:size(obj.collisionGeometry.lines, 2)
+        % Update plotting
+        for ii = 1:size(obj.collisionGeometry.lines(:, jj), 1)
+            obj.collisionGeometry.lines(ii, jj).XData = obj.collisionGeometry.lines(ii, jj).XData + deltaPos(1);
+            obj.collisionGeometry.lines(ii, jj).YData = obj.collisionGeometry.lines(ii, jj).YData + deltaPos(2);
+            obj.collisionGeometry.lines(ii, jj).ZData = obj.collisionGeometry.lines(ii, jj).ZData + deltaPos(3);
+        end
+    end
+
+    % Update FOV geometry surfaces
+    for jj = 1:size(obj.fovGeometry.surface, 2)
+        % Update each plot
+        obj.fovGeometry.surface(jj).XData = obj.fovGeometry.surface(jj).XData + deltaPos(1);
+        obj.fovGeometry.surface(jj).YData = obj.fovGeometry.surface(jj).YData + deltaPos(2);
+        obj.fovGeometry.surface(jj).ZData = obj.fovGeometry.surface(jj).ZData + deltaPos(3);
+    end
+end

@miSim/initialize.m

@@ -0,0 +1,49 @@
+function obj = initialize(obj, domain, objective, agents, timestep, partitoningFreq, maxIter, obstacles)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+        domain (1, 1) {mustBeGeometry};
+        objective (1, 1) {mustBeA(objective, 'sensingObjective')};
+        agents (:, 1) cell;
+        timestep (:, 1) double = 0.05;
+        partitoningFreq (:, 1) double = 0.25
+        maxIter (:, 1) double = 1000;
+        obstacles (:, 1) cell {mustBeGeometry} = cell(0, 1);
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Define simulation time parameters
+    obj.timestep = timestep;
+    obj.maxIter = maxIter - 1;
+
+    % Define domain
+    obj.domain = domain;
+    obj.partitioningFreq = partitoningFreq;
+
+    % Add geometries representing obstacles within the domain
+    obj.obstacles = obstacles;
+
+    % Define objective
+    obj.objective = objective;
+
+    % Define agents
+    obj.agents = agents;
+
+    % Compute adjacency matrix
+    obj = obj.updateAdjacency();
+
+    % Set up times to iterate over
+    obj.times = linspace(0, obj.timestep * obj.maxIter, obj.maxIter+1)';
+    obj.partitioningTimes = obj.times(obj.partitioningFreq:obj.partitioningFreq:size(obj.times, 1));
+
+    % Prepare performance data store (at t = 0, all have 0 performance)
+    obj.fPerf = figure;
+    obj.perf = [zeros(size(obj.agents, 1) + 1, 1), NaN(size(obj.agents, 1) + 1, size(obj.partitioningTimes, 1) - 1)];
+
+    % Create initial partitioning
+    obj = obj.partition();
+
+    % Set up plots showing initialized state
+    obj = obj.plot();
+end

@miSim/miSim.m

@@ -0,0 +1,58 @@
+classdef miSim
+    % multiagent interconnection simulation
+
+    % Simulation parameters
+    properties (SetAccess = private, GetAccess = public)
+        timestep = NaN; % delta time interval for simulation iterations
+        partitioningFreq = NaN; % number of simulation timesteps at which the partitioning routine is re-run
+        maxIter = NaN; % maximum number of simulation iterations
+        domain = rectangularPrism;
+        objective = sensingObjective;
+        obstacles = cell(0, 1); % geometries that define obstacles within the domain
+        agents = cell(0, 1); % agents that move within the domain
+        adjacency = NaN; % Adjacency matrix representing communications network graph
+        sensorPerformanceMinimum = 1e-6; % minimum sensor performance to allow assignment of a point in the domain to a partition
+        partitioning = NaN;
+        performance = NaN; % current cumulative sensor performance
+        oldMeanTotalPerf = 0;
+
+        fPerf; % performance plot figure
+    end
+
+    properties (Access = private)
+        % Sim
+        t = NaN; % current sim time
+        perf; % sensor performance timeseries array
+        times;
+        partitioningTimes;
+
+        % Plot objects
+        f = firstPlotSetup(); % main plotting tiled layout figure
+        connectionsPlot; % objects for lines connecting agents in spatial plots
+        graphPlot; % objects for abstract network graph plot
+        partitionPlot; % objects for partition plot
+
+        performancePlot; % objects for sensor performance plot
+
+        % Indicies for various plot types in the main tiled layout figure
+        spatialPlotIndices = [6, 4, 3, 2];
+        objectivePlotIndices = [6, 4];
+        networkGraphIndex = 5;
+        partitionGraphIndex = 1;
+    end
+
+    methods (Access = public)
+        [obj] = initialize(obj, domain, objective, agents, timestep, partitoningFreq, maxIter, obstacles);
+        [obj] = run(obj);
+        [obj] = partition(obj);
+        [obj] = updateAdjacency(obj);
+        [obj] = plot(obj);
+        [obj] = plotConnections(obj);
+        [obj] = plotPartitions(obj);
+        [obj] = plotGraph(obj);
+        [obj] = updatePlots(obj, updatePartitions);
+    end
+    methods (Access = private)
+        [v] = setupVideoWriter(obj);
+    end
+end

@miSim/partition.m

@@ -0,0 +1,41 @@
+function obj = partition(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Assess sensing performance of each agent at each sample point
+    % in the domain
+    agentPerformances = cellfun(@(x) reshape(x.sensorModel.sensorPerformance(x.pos, x.pan, x.tilt, [obj.objective.X(:), obj.objective.Y(:), zeros(size(obj.objective.X(:)))]), size(obj.objective.X)), obj.agents, 'UniformOutput', false);
+    agentPerformances{end + 1} = obj.sensorPerformanceMinimum * ones(size(agentPerformances{end})); % add additional layer to represent the threshold that has to be cleared for assignment to any partiton
+    agentPerformances = cat(3, agentPerformances{:});
+    
+    % Get highest performance value at each point
+    [~, idx] = max(agentPerformances, [], 3);
+
+    % Collect agent indices in the same way as performance
+    agentInds = cellfun(@(x) x.index * ones(size(obj.objective.X)), obj.agents, 'UniformOutput', false);
+    agentInds{end + 1} = zeros(size(agentInds{end})); % index for no assignment
+    agentInds = cat(3, agentInds{:});
+
+    % Use highest performing agent's index to form partitions
+    [m, n, ~] = size(agentInds);
+    [jj, kk] = ndgrid(1:m, 1:n);
+    obj.partitioning = agentInds(sub2ind(size(agentInds), jj, kk, idx));
+
+    % Get individual agent sensor performance
+    nowIdx = [0; obj.partitioningTimes] == obj.t;
+    if isnan(obj.t)
+        nowIdx = 1;
+    end
+    for ii = 1:size(obj.agents, 1)
+        idx = obj.partitioning == ii;
+        agentPerformance = squeeze(agentPerformances(:, :, ii));
+        obj.perf(ii, nowIdx) = sum(agentPerformance(idx) .* obj.objective.values(idx));
+    end
+
+    % Current total performance
+    obj.perf(end, nowIdx) = sum(obj.perf(1:(end - 1), nowIdx));
+end

@miSim/plot.m

@@ -0,0 +1,43 @@
+function obj = plot(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Plot domain
+    [obj.domain, obj.f] = obj.domain.plotWireframe(obj.spatialPlotIndices);
+
+    % Plot obstacles
+    for ii = 1:size(obj.obstacles, 1)
+        [obj.obstacles{ii}, obj.f] = obj.obstacles{ii}.plotWireframe(obj.spatialPlotIndices, obj.f);
+    end
+
+    % Plot objective gradient
+    obj.f = obj.domain.objective.plot(obj.objectivePlotIndices, obj.f);
+
+    % Plot agents and their collision geometries
+    for ii = 1:size(obj.agents, 1)
+        [obj.agents{ii}, obj.f] = obj.agents{ii}.plot(obj.spatialPlotIndices, obj.f);
+    end
+
+    % Plot communication links
+    obj = obj.plotConnections();
+
+    % Plot abstract network graph
+    obj = obj.plotGraph();
+
+    % Plot domain partitioning
+    obj = obj.plotPartitions();
+
+    % Enforce plot limits
+    for ii = 1:size(obj.spatialPlotIndices, 2)
+        xlim(obj.f.Children(1).Children(obj.spatialPlotIndices(ii)), [obj.domain.minCorner(1), obj.domain.maxCorner(1)]);
+        ylim(obj.f.Children(1).Children(obj.spatialPlotIndices(ii)), [obj.domain.minCorner(2), obj.domain.maxCorner(2)]);
+        zlim(obj.f.Children(1).Children(obj.spatialPlotIndices(ii)), [obj.domain.minCorner(3), obj.domain.maxCorner(3)]);
+    end
+
+    % Plot performance
+    obj = obj.plotPerformance();
+end

@miSim/plotConnections.m

@@ -0,0 +1,42 @@
+function obj = plotConnections(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Iterate over lower triangle off-diagonal region of the 
+    % adjacency matrix to plot communications links between agents
+    X = []; Y = []; Z = [];
+    for ii = 2:size(obj.adjacency, 1)
+        for jj = 1:(ii - 1)
+            if obj.adjacency(ii, jj)
+                X = [X; obj.agents{ii}.pos(1), obj.agents{jj}.pos(1)];
+                Y = [Y; obj.agents{ii}.pos(2), obj.agents{jj}.pos(2)];
+                Z = [Z; obj.agents{ii}.pos(3), obj.agents{jj}.pos(3)];
+            end
+        end
+    end
+    X = X'; Y = Y'; Z = Z';
+
+    % Plot the connections
+    if isnan(obj.spatialPlotIndices)
+        hold(obj.f.CurrentAxes, "on");
+        o = plot3(obj.f.CurrentAxes, X, Y, Z, 'Color', 'g', 'LineWidth', 2, 'LineStyle', '--');
+        hold(obj.f.CurrentAxes, "off");
+    else
+        hold(obj.f.Children(1).Children(obj.spatialPlotIndices(1)), "on");
+        o = plot3(obj.f.Children(1).Children(obj.spatialPlotIndices(1)), X, Y, Z, 'Color', 'g', 'LineWidth', 2, 'LineStyle', '--');
+        hold(obj.f.Children(1).Children(obj.spatialPlotIndices(1)), "off");
+    end
+
+    % Copy to other plots
+    if size(obj.spatialPlotIndices, 2) > 1
+        for ii = 2:size(obj.spatialPlotIndices, 2)
+            o = [o, copyobj(o(:, 1), obj.f.Children(1).Children(obj.spatialPlotIndices(ii)))];
+        end 
+    end
+
+    obj.connectionsPlot = o;
+end

@miSim/plotGraph.m

@@ -0,0 +1,28 @@
+function obj = plotGraph(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Form graph from adjacency matrix
+    G = graph(obj.adjacency, 'omitselfloops');
+
+    % Plot graph object
+    if isnan(obj.networkGraphIndex)
+        hold(obj.f.CurrentAxes, 'on');
+        o = plot(obj.f.CurrentAxes, G, 'LineStyle', '--', 'EdgeColor', 'g', 'NodeColor', 'k', 'LineWidth', 2);
+        hold(obj.f.CurrentAxes, 'off');
+    else
+        hold(obj.f.Children(1).Children(obj.networkGraphIndex(1)), 'on');
+        o = plot(obj.f.Children(1).Children(obj.networkGraphIndex(1)), G, 'LineStyle', '--', 'EdgeColor', 'g', 'NodeColor', 'k', 'LineWidth', 2);
+        hold(obj.f.Children(1).Children(obj.networkGraphIndex(1)), 'off');
+        if size(obj.networkGraphIndex, 2) > 1
+            for ii = 2:size(ind, 2)
+                o = [o; copyobj(o(1), obj.f.Children(1).Children(obj.networkGraphIndex(ii)))];
+            end
+        end
+    end
+    obj.graphPlot = o;
+end

@miSim/plotPartitions.m

@@ -0,0 +1,24 @@
+function obj = plotPartitions(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    if isnan(obj.partitionGraphIndex)
+        hold(obj.f.CurrentAxes, 'on');
+        o = imagesc(obj.f.CurrentAxes, obj.partitioning);
+        hold(obj.f.CurrentAxes, 'off');
+    else
+        hold(obj.f.Children(1).Children(obj.partitionGraphIndex(1)), 'on');
+        o = imagesc(obj.f.Children(1).Children(obj.partitionGraphIndex(1)), obj.partitioning);
+        hold(obj.f.Children(1).Children(obj.partitionGraphIndex(1)), 'on');
+        if size(obj.partitionGraphIndex, 2) > 1
+            for ii = 2:size(ind, 2)
+                o = [o, copyobj(o(1), obj.f.Children(1).Children(obj.partitionGraphIndex(ii)))];
+            end
+        end
+    end
+    obj.partitionPlot = o;
+end

@miSim/plotPerformance.m

@@ -0,0 +1,36 @@
+function obj = plotPerformance(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    axes(obj.fPerf);
+    title(obj.fPerf.Children(1), "Sensor Performance");
+    xlabel(obj.fPerf.Children(1), 'Time (s)');
+    ylabel(obj.fPerf.Children(1), 'Sensor Performance');
+    grid(obj.fPerf.Children(1), 'on');
+
+    % Plot current cumulative performance
+    hold(obj.fPerf.Children(1), 'on');
+    o = plot(obj.fPerf.Children(1), obj.perf(end, :));
+    hold(obj.fPerf.Children(1), 'off');
+
+    % Plot current agent performance
+    for ii = 1:(size(obj.perf, 1) - 1)
+        hold(obj.fPerf.Children(1), 'on');
+        o = [o; plot(obj.fPerf.Children(1), obj.perf(ii, :))];
+        hold(obj.fPerf.Children(1), 'off');
+    end
+
+    % Add legend
+    agentStrings = repmat("Agent %d", size(obj.perf, 1) - 1, 1);
+    for ii = 1:size(agentStrings, 1)
+        agentStrings(ii) = sprintf(agentStrings(ii), ii);
+    end
+    agentStrings = ["Total"; agentStrings];
+    legend(obj.fPerf.Children(1), agentStrings, 'Location', 'northwest');
+
+    obj.performancePlot = o;
+end

@miSim/run.m

@@ -0,0 +1,57 @@
+function [obj] = run(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Start video writer
+    v = obj.setupVideoWriter();
+    v.open();
+
+    steady = 0;
+    for ii = 1:size(obj.times, 1)
+        % Display current sim time
+        obj.t = obj.times(ii);
+        fprintf("Sim Time: %4.2f (%d/%d)\n", obj.t, ii, obj.maxIter + 1);
+
+        % Check if it's time for new partitions
+        updatePartitions = false;
+        if ismember(obj.t, obj.partitioningTimes)
+            % Check if it's time to end the sim (performance has settled)
+            if obj.t >= obj.partitioningTimes(5)
+                idx = find(obj.t == obj.partitioningTimes);
+                newMeanTotalPerf = mean(obj.perf(end, ((idx - 5 + 1):idx)));
+                if (obj.oldMeanTotalPerf * 0.95 <= newMeanTotalPerf) && (newMeanTotalPerf <= max(1e-6, obj.oldMeanTotalPerf * 1.05))
+                    steady = steady + 1;
+                    if steady >= 3
+                        fprintf("Performance is stable, terminating early at %4.2f (%d/%d)\n", obj.t, ii, obj.maxIter + 1);
+                        break; % performance is not improving further, exit main sim loop
+                    end
+                end
+                obj.oldMeanTotalPerf = newMeanTotalPerf;
+            end
+            updatePartitions = true;
+            obj = obj.partition();
+        end
+
+        % Iterate over agents to simulate their motion
+        for jj = 1:size(obj.agents, 1)
+            obj.agents{jj} = obj.agents{jj}.run(obj.objective, obj.domain, obj.partitioning);
+        end
+
+        % Update adjacency matrix
+        obj = obj.updateAdjacency();
+
+        % Update plots
+        obj = obj.updatePlots(updatePartitions);
+
+        % Write frame in to video
+        I = getframe(obj.f);
+        v.writeVideo(I);
+    end
+
+    % Close video file
+    v.close();
+end

@miSim/setupVideoWriter.m

@@ -0,0 +1,17 @@
+function v = setupVideoWriter(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        v (1, 1) {mustBeA(v, 'VideoWriter')};
+    end
+
+    if ispc || ismac
+        v = VideoWriter(fullfile('sandbox', strcat(string(datetime('now'), 'yyyy_MM_dd_HH_mm_ss'), '_miSimHist')), 'MPEG-4');
+    elseif isunix
+        v = VideoWriter(fullfile('.', strcat(string(datetime('now'), 'yyyy_MM_dd_HH_mm_ss'), '_miSimHist')), 'Motion JPEG AVI');
+    end
+    
+    v.FrameRate = 1 / obj.timestep;
+    v.Quality = 90;
+end

@miSim/updateAdjacency.m

@@ -0,0 +1,32 @@
+function obj = updateAdjacency(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Initialize assuming only self-connections
+    A = logical(eye(size(obj.agents, 1)));
+
+    % Check lower triangle off-diagonal connections
+    for ii = 2:size(A, 1)
+        for jj = 1:(ii - 1)
+            if norm(obj.agents{ii}.pos - obj.agents{jj}.pos) <= min([obj.agents{ii}.comRange, obj.agents{jj}.comRange])
+                % Make sure that obstacles don't obstruct the line
+                % of sight, breaking the connection
+                for kk = 1:size(obj.obstacles, 1)
+                    if ~obj.obstacles{kk}.containsLine(obj.agents{ii}.pos, obj.agents{jj}.pos)
+                        A(ii, jj) = true;
+                    end
+                end
+                % need extra handling for cases with no obstacles
+                if isempty(obj.obstacles)
+                    A(ii, jj) = true;
+                end
+            end
+        end
+    end
+
+    obj.adjacency = A | A';
+end

@miSim/updatePlots.m

@@ -0,0 +1,54 @@
+function [obj] = updatePlots(obj, updatePartitions)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+        updatePartitions (1, 1) logical = false;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'miSim')};
+    end
+
+    % Update agent positions, collision geometries
+    for ii = 1:size(obj.agents, 1)
+        obj.agents{ii}.updatePlots();
+    end
+
+    % The remaining updates might be possible to do in a clever way
+    % that moves existing lines instead of clearing and 
+    % re-plotting, which is much better for performance boost
+
+    % Update agent connections plot
+    delete(obj.connectionsPlot);
+    obj = obj.plotConnections();
+
+    % Update network graph plot
+    delete(obj.graphPlot);
+    obj = obj.plotGraph();
+
+    % Update partitioning plot
+    if updatePartitions
+        delete(obj.partitionPlot);
+        obj = obj.plotPartitions();
+    end
+
+    % reset plot limits to fit domain
+    for ii = 1:size(obj.spatialPlotIndices, 2)
+        xlim(obj.f.Children(1).Children(obj.spatialPlotIndices(ii)), [obj.domain.minCorner(1), obj.domain.maxCorner(1)]);
+        ylim(obj.f.Children(1).Children(obj.spatialPlotIndices(ii)), [obj.domain.minCorner(2), obj.domain.maxCorner(2)]);
+        zlim(obj.f.Children(1).Children(obj.spatialPlotIndices(ii)), [obj.domain.minCorner(3), obj.domain.maxCorner(3)]);
+    end
+    drawnow;
+    
+    % Update performance plot
+    if updatePartitions
+        % find index corresponding to the current time
+        nowIdx = [0; obj.partitioningTimes] == obj.t;
+        nowIdx = find(nowIdx);
+
+        % Re-normalize performance plot
+        normalizingFactor = 1/max(obj.perf(end, 1:nowIdx));
+        obj.performancePlot(1).YData(1:nowIdx) = obj.perf(end, 1:nowIdx) * normalizingFactor;
+        for ii = 2:size(obj.performancePlot, 1)
+            obj.performancePlot(ii).YData(1:nowIdx) = obj.perf(ii - 1, 1:nowIdx) * normalizingFactor;
+        end
+    end
+end

@sensingObjective/initialize.m

@@ -0,0 +1,40 @@
+function obj = initialize(obj, objectiveFunction, domain, discretizationStep, protectedRange)
+    arguments (Input)
+        obj (1,1) {mustBeA(obj, 'sensingObjective')};
+        objectiveFunction (1, 1) {mustBeA(objectiveFunction, 'function_handle')};
+        domain (1, 1) {mustBeGeometry};
+        discretizationStep (1, 1) double = 1;
+        protectedRange (1, 1) double = 1;
+    end
+    arguments (Output)
+        obj (1,1) {mustBeA(obj, 'sensingObjective')};
+    end
+
+    obj.groundAlt = domain.minCorner(3);
+    obj.protectedRange = protectedRange;
+
+    % Extract footprint limits
+    xMin = min(domain.footprint(:, 1));
+    xMax = max(domain.footprint(:, 1));
+    yMin = min(domain.footprint(:, 2));
+    yMax = max(domain.footprint(:, 2));
+
+    xGrid = unique([xMin:discretizationStep:xMax, xMax]);
+    yGrid = unique([yMin:discretizationStep:yMax, yMax]);
+    
+    % Store grid points for plotting later
+    [obj.X, obj.Y] = meshgrid(xGrid, yGrid);
+
+    % Evaluate function over grid points
+    obj.objectiveFunction = objectiveFunction;
+    obj.values = reshape(obj.objectiveFunction(obj.X, obj.Y), size(obj.X));
+    
+    % Normalize
+    obj.values = obj.values ./ max(obj.values, [], "all");
+
+    % store ground position
+    idx = obj.values == 1;
+    obj.groundPos = [obj.X(idx), obj.Y(idx)];
+
+    assert(domain.distance([obj.groundPos, domain.center(3)]) > protectedRange, "Domain is crowding the sensing objective")
+end

@sensingObjective/initializeRandomMvnpdf.m

@@ -0,0 +1,27 @@
+function obj = initializeRandomMvnpdf(obj, domain, discretizationStep, protectedRange)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'sensingObjective')};
+        domain (1, 1) {mustBeGeometry};
+        discretizationStep (1, 1) double = 1;
+        protectedRange (1, 1) double = 1;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'sensingObjective')};
+    end
+
+    % Set random objective position
+    mu = domain.minCorner;
+    while domain.distance(mu) < protectedRange
+        mu = domain.random();
+    end
+    mu = mu(1:2);
+
+    % Set random distribution parameters
+    sig = [2 + rand * 2, 1; 1, 2 + rand * 2];
+
+    % Set up random bivariate normal distribution function
+    objectiveFunction = @(x, y) mvnpdf([x(:), y(:)], mu, sig);
+
+    % Regular initialization
+    obj = obj.initialize(objectiveFunction, domain, discretizationStep, protectedRange);
+end

@sensingObjective/plot.m

@@ -0,0 +1,35 @@
+function f = plot(obj, ind, f)
+    arguments (Input)
+        obj (1,1) {mustBeA(obj, 'sensingObjective')};
+        ind (1, :) double = NaN;
+        f (1,1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
+    end
+    arguments (Output)
+        f (1,1) {mustBeA(f, 'matlab.ui.Figure')};
+    end
+
+    % Create axes if they don't already exist
+    f = firstPlotSetup(f);
+
+    % Plot gradient on the "floor" of the domain
+    if isnan(ind)
+        hold(f.CurrentAxes, "on");
+        o = surf(f.CurrentAxes, obj.X, obj.Y, repmat(obj.groundAlt, size(obj.X)), obj.values ./ max(obj.values, [], "all"), 'EdgeColor', 'none');
+        o.HitTest = 'off';
+        o.PickableParts = 'none';
+        hold(f.CurrentAxes, "off");
+    else
+        hold(f.Children(1).Children(ind(1)), "on");
+        o = surf(f.Children(1).Children(ind(1)), obj.X, obj.Y, repmat(obj.groundAlt, size(obj.X)), obj.values ./ max(obj.values, [], "all"), 'EdgeColor', 'none');
+        o.HitTest = 'off';
+        o.PickableParts = 'none';
+        hold(f.Children(1).Children(ind(1)), "off");
+    end
+
+    % Add to other perspectives
+    if size(ind, 2) > 1
+        for ii = 2:size(ind, 2)
+            copyobj(o, f.Children(1).Children(ind(ii)));
+        end
+    end
+end

@sensingObjective/sensingObjective.m

@@ -0,0 +1,20 @@
+classdef sensingObjective
+    % Sensing objective definition parent class
+    properties (SetAccess = private, GetAccess = public)
+        label = "";
+        groundAlt = 0;
+        groundPos = [0, 0];
+        discretizationStep = 1;
+        objectiveFunction = @(x, y) 0; % define objective functions over a grid in this manner
+        X = [];
+        Y = [];
+        values = [];
+        protectedRange = 1; % keep obstacles from crowding objective
+    end
+
+    methods (Access = public)
+        [obj] = initialize(obj, objectiveFunction, domain, discretizationStep, protectedRange);
+        [obj] = initializeRandomMvnpdf(obj, domain, protectedRange, discretizationStep, protectedRange);
+        [f  ] = plot(obj, ind, f);
+    end
+end

agent.m

@@ -1,140 +0,0 @@
-classdef agent
-    properties (SetAccess = private, GetAccess = public)
-        % Identifiers
-        index = NaN;
-        label = "";
-
-        % Sensor
-        sensingFunction = @(r) 0.5; % probability of detection as a function of range
-        sensingLength = 0.05; % length parameter used by sensing function
-
-        % State
-        lastPos = NaN(1, 3); % position from previous timestep
-        pos = NaN(1, 3); % current position
-        vel = NaN(1, 3); % current velocity
-        cBfromC = NaN(3); % current DCM body from sim cartesian (assume fixed for now)
-
-        % Collision
-        collisionGeometry;
-
-        % Communication
-        comRange = NaN;
-
-        % Plotting
-        scatterPoints;
-    end
-
-    methods (Access = public)
-        function obj = initialize(obj, pos, vel, cBfromC, collisionGeometry, sensingFunction, sensingLength, comRange, index, label)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-                pos (1, 3) double;
-                vel (1, 3) double;
-                cBfromC (3, 3) double {mustBeDcm};
-                collisionGeometry (1, 1) {mustBeGeometry};
-                sensingFunction (1, 1) {mustBeA(sensingFunction, 'function_handle')} = @(r) 0.5;
-                sensingLength (1, 1) double = NaN;
-                comRange (1, 1) double = NaN;
-                index (1, 1) double = NaN;
-                label (1, 1) string = "";
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-            end
-
-            obj.pos = pos;
-            obj.vel = vel;
-            obj.cBfromC = cBfromC;
-            obj.collisionGeometry = collisionGeometry;
-            obj.sensingFunction = sensingFunction;
-            obj.sensingLength = sensingLength;
-            obj.comRange = comRange;
-            obj.index = index;
-            obj.label = label;
-        end
-        function obj = run(obj, objectiveFunction, domain)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-                objectiveFunction (1, 1) {mustBeA(objectiveFunction, 'function_handle')};
-                domain (1, 1) {mustBeGeometry};
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-            end
-
-            % Do sensing to determine target position
-            nextPos = obj.sensingFunction(objectiveFunction, domain, obj.pos, obj.sensingLength);
-
-            % Move to next position
-            % (dynamics not modeled at this time)
-            obj.lastPos = obj.pos;
-            obj.pos = nextPos;
-
-            % Calculate movement
-            d = obj.pos - obj.collisionGeometry.center;
-
-            % Reinitialize collision geometry in the new position
-            obj.collisionGeometry = obj.collisionGeometry.initialize([obj.collisionGeometry.minCorner; obj.collisionGeometry.maxCorner] + d, obj.collisionGeometry.tag, obj.collisionGeometry.label);
-        end
-        function updatePlots(obj)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-            end
-            arguments (Output)
-            end
-
-            % Scatterplot point positions
-            for ii = 1:size(obj.scatterPoints, 1)
-                obj.scatterPoints(ii).XData = obj.pos(1);
-                obj.scatterPoints(ii).YData = obj.pos(2);
-                obj.scatterPoints(ii).ZData = obj.pos(3);
-            end
-
-            % Find change in agent position since last timestep
-            deltaPos = obj.pos - obj.lastPos;
-
-            % Collision geometry edges
-            for jj = 1:size(obj.collisionGeometry.lines, 2)
-                % Update plotting
-                for ii = 1:size(obj.collisionGeometry.lines(:, jj), 1)
-                    obj.collisionGeometry.lines(ii, jj).XData = obj.collisionGeometry.lines(ii, jj).XData + deltaPos(1);
-                    obj.collisionGeometry.lines(ii, jj).YData = obj.collisionGeometry.lines(ii, jj).YData + deltaPos(2);
-                    obj.collisionGeometry.lines(ii, jj).ZData = obj.collisionGeometry.lines(ii, jj).ZData + deltaPos(3);
-                end
-            end
-
-            % Network connections
-        end
-        function [obj, f] = plot(obj, f)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'agent')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Create axes if they don't already exist
-            f = firstPlotSetup(f);
-
-            % Plot points representing the agent position
-            hold(f.CurrentAxes, "on");
-            o = scatter3(obj.pos(1), obj.pos(2), obj.pos(3), 'filled', 'ko', 'SizeData', 25);
-            hold(f.CurrentAxes, "off");
-
-            % Check if this is a tiled layout figure
-            if strcmp(f.Children(1).Type, 'tiledlayout')
-                % Add to other perspectives
-                o = [o; copyobj(o(1), f.Children(1).Children(2))];
-                o = [o; copyobj(o(1), f.Children(1).Children(3))];
-                o = [o; copyobj(o(1), f.Children(1).Children(5))];
-            end
-
-            obj.scatterPoints = o;
-
-            % Plot collision geometry
-            [obj.collisionGeometry, f] = obj.collisionGeometry.plotWireframe(f);
-        end
-    end
-end

firstPlotSetup.m

@@ -1,49 +0,0 @@
-function f = firstPlotSetup(f)
-    if isempty(f.CurrentAxes)
-        tiledlayout(f, 4, 3, "TileSpacing", "tight", "Padding", "compact");
-
-        % Top-down view
-        nexttile(1, [1, 2]);
-        axes(f.Children(1).Children(1));
-        axis(f.Children(1).Children(1), "image");
-        grid(f.Children(1).Children(1), "on");
-        view(f.Children(1).Children(1), 0, 90);
-        xlabel(f.Children(1).Children(1), "X"); ylabel(f.Children(1).Children(1), "Y");
-        title(f.Children(1).Children(1), "Top-down Perspective");
-
-        % Communications graph
-        nexttile(3, [1, 1]);
-        axes(f.Children(1).Children(1));
-        axis(f.Children(1).Children(1), "image");
-        grid(f.Children(1).Children(1), "off");
-        view(f.Children(1).Children(1), 0, 0);
-        title(f.Children(1).Children(1), "Network Graph");
-
-        % 3D view
-        nexttile(4, [2, 2]);
-        axes(f.Children(1).Children(1));
-        axis(f.Children(1).Children(1), "image");
-        grid(f.Children(1).Children(1), "on");
-        view(f.Children(1).Children(1), 3);
-        xlabel(f.Children(1).Children(1), "X"); ylabel(f.Children(1).Children(1), "Y"); zlabel(f.Children(1).Children(1), "Z");
-        title(f.Children(1).Children(1), "3D Perspective");
-
-        % Side-on view
-        nexttile(6, [2, 1]);
-        axes(f.Children(1).Children(1));
-        axis(f.Children(1).Children(1), "image");
-        grid(f.Children(1).Children(1), "on");
-        view(f.Children(1).Children(1), 90, 0);
-        ylabel(f.Children(1).Children(1), "Y"); zlabel(f.Children(1).Children(1), "Z");
-        title(f.Children(1).Children(1), "Side-on Perspective");
-
-        % Front-on view
-        nexttile(10, [1, 2]);
-        axes(f.Children(1).Children(1));
-        axis(f.Children(1).Children(1), "image");
-        grid(f.Children(1).Children(1), "on");
-        view(f.Children(1).Children(1), 0, 0);
-        xlabel(f.Children(1).Children(1), "X"); zlabel(f.Children(1).Children(1), "Z");
-        title(f.Children(1).Children(1), "Front-on Perspective");
-    end
-end

geometries/@cone/cone.m

@@ -0,0 +1,22 @@
+classdef cone
+    % Conical geometry
+    properties (SetAccess = private, GetAccess = public)
+        % Meta
+        tag = REGION_TYPE.INVALID;
+        label = "";
+
+        % Spatial
+        center = NaN;
+        radius = NaN;
+        height = NaN;
+
+        % Plotting
+        surface;
+        n = 32;
+    end
+
+    methods (Access = public)
+        [obj   ] = initialize(obj, center, radius, height, tag, label);
+        [obj, f] = plot(obj, ind, f);
+    end
+end

geometries/@cone/initialize.m

@@ -0,0 +1,19 @@
+function obj = initialize(obj, center, radius, height, tag, label)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'cone')};
+        center (1, 3) double;
+        radius (1, 1) double;
+        height (1, 1) double;
+        tag (1, 1) REGION_TYPE = REGION_TYPE.INVALID;
+        label (1, 1) string = "";
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'cone')};
+    end
+
+    obj.center = center;
+    obj.radius = radius;
+    obj.height = height;
+    obj.tag = tag;
+    obj.label = label;
+end

geometries/@cone/plot.m

@@ -0,0 +1,43 @@
+function [obj, f] = plot(obj, ind, f)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'cone')};
+        ind (1, :) double = NaN;
+        f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'cone')};
+        f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
+    end
+    
+    % Create axes if they don't already exist
+    f = firstPlotSetup(f);
+    
+    % Plot cone
+    [X, Y, Z] = cylinder([obj.radius, 0], obj.n);
+    
+    % Scale to match height
+    Z = Z * obj.height;
+    
+    % Move to center location
+    X = X + obj.center(1);
+    Y = Y + obj.center(2);
+    Z = Z + obj.center(3);
+    
+    % Plot
+    if isnan(ind)
+        o = surf(f.CurrentAxes, X, Y, Z);
+    else
+        hold(f.Children(1).Children(ind(1)), "on");
+        o = surf(f.Children(1).Children(ind(1)), X, Y, Z, ones([size(Z), 1]) .* reshape(obj.tag.color, 1, 1, 3), 'FaceAlpha', 0.25, 'EdgeColor', 'none');
+        hold(f.Children(1).Children(ind(1)), "off");
+    end
+    
+    % Copy to other requested tiles
+    if numel(ind) > 1
+        for ii = 2:size(ind, 2)
+            o = [o, copyobj(o(:, 1), f.Children(1).Children(ind(ii)))];
+        end
+    end
+    
+    obj.surface = o;
+end

geometries/@rectangularPrism/contains.m

@@ -0,0 +1,10 @@
+function c = contains(obj, pos)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        pos (:, 3) double;
+    end
+    arguments (Output)
+        c (:, 1) logical
+    end
+    c = all(pos >= repmat(obj.minCorner, size(pos, 1), 1), 2) & all(pos <= repmat(obj.maxCorner, size(pos, 1), 1), 2);
+end

geometries/@rectangularPrism/containsLine.m

@@ -0,0 +1,41 @@
+function c = containsLine(obj, pos1, pos2)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        pos1 (1, 3) double;
+        pos2 (1, 3) double;
+    end
+    arguments (Output)
+        c (1, 1) logical
+    end
+    
+    d = pos2 - pos1;
+    
+    % edge case where the line is parallel to the geometry
+    if abs(d) < 1e-12
+        % check if it happens to start or end inside or outside of
+        % the geometry
+        if obj.contains(pos1) || obj.contains(pos2)
+            c = true;
+        else
+            c = false;
+        end
+        return;
+    end
+    
+    tmin = -inf;        
+    tmax = inf;
+    
+    % Standard case
+    for ii = 1:3
+        t1 = (obj.minCorner(ii) - pos1(ii)) / d(ii);
+        t2 = (obj.maxCorner(ii) - pos2(ii)) / d(ii);
+        tmin = max(tmin, min(t1, t2));
+        tmax = min(tmax, max(t1, t2));
+        if tmin > tmax
+            c = false;
+            return;
+        end
+    end
+    
+    c = (tmax >= 0) && (tmin <= 1);
+    end

geometries/@rectangularPrism/distance.m

@@ -0,0 +1,32 @@
+function d = distance(obj, pos)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        pos (:, 3) double;
+    end
+    arguments (Output)
+        d (:, 1) double
+    end
+    if obj.contains(pos)
+        % Queried point is inside geometry
+        % find minimum distance to any face
+        d = min([pos(1) - obj.minCorner(1), ...
+                 pos(2) - obj.minCorner(2), ...
+                 pos(3) - obj.minCorner(3), ...
+                 obj.maxCorner(1) - pos(1), ...
+                 obj.maxCorner(2) - pos(2), ...
+                 obj.maxCorner(3) - pos(3)]);
+    else
+        % Queried point is outside geometry
+        cPos = NaN(1, 3);
+        for ii = 1:3
+            if pos(ii) < obj.minCorner(ii)
+                cPos(ii) = obj.minCorner(ii);
+            elseif pos(ii) > obj.maxCorner(ii)
+                cPos(ii) = obj.maxCorner(ii);
+            else
+                cPos(ii) = pos(ii);
+            end
+        end
+        d = norm(cPos - pos);
+    end
+end

geometries/@rectangularPrism/initialize.m

@@ -0,0 +1,47 @@
+function obj = initialize(obj, bounds, tag, label, objectiveFunction, discretizationStep)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        bounds (2, 3) double;
+        tag (1, 1) REGION_TYPE = REGION_TYPE.INVALID;
+        label (1, 1) string = "";
+        objectiveFunction (1, 1) function_handle = @(x, y) 1;
+        discretizationStep (1, 1) double = 1;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+    end
+
+    obj.tag = tag;
+    obj.label = label;
+
+    % Define geometry bounds by LL corner and UR corner
+    obj.minCorner = bounds(1, 1:3);
+    obj.maxCorner = bounds(2, 1:3);
+
+    % Compute L, W, H
+    obj.dimensions = [obj.maxCorner(1) - obj.minCorner(1), obj.maxCorner(2) - obj.minCorner(2), obj.maxCorner(3) - obj.minCorner(3)];
+
+    % Compute center
+    obj.center = obj.minCorner + obj.dimensions ./ 2;
+
+    % Compute vertices
+    obj.vertices = [obj.minCorner;
+                    obj.maxCorner(1), obj.minCorner(2:3);
+                    obj.maxCorner(1:2), obj.minCorner(3);
+                    obj.minCorner(1), obj.maxCorner(2), obj.minCorner(3);
+                    obj.minCorner(1:2), obj.maxCorner(3);
+                    obj.maxCorner(1), obj.minCorner(2), obj.maxCorner(3);
+                    obj.minCorner(1), obj.maxCorner(2:3)
+                    obj.maxCorner;];
+
+    % Compute footprint
+    obj.footprint = [obj.minCorner(1:2); ...
+                     [obj.minCorner(1), obj.maxCorner(2)]; ...
+                     [obj.maxCorner(1), obj.minCorner(2)]; ...
+                     obj.maxCorner(1:2)];
+
+    % Instantiate sensingObjective only for DOMAIN-type regions
+    if tag == REGION_TYPE.DOMAIN
+        obj.objective = sensingObjective;
+    end
+end

geometries/@rectangularPrism/initializeRandom.m

@@ -0,0 +1,44 @@
+function [obj] = initializeRandom(obj, tag, label, minDimension, maxDimension, domain)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        tag (1, 1) REGION_TYPE = REGION_TYPE.INVALID;
+        label (1, 1) string = "";
+        minDimension (1, 1) double = 10;
+        maxDimension (1, 1) double= 20;
+        domain (1, 1) {mustBeGeometry} = rectangularPrism;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+    end
+    
+    % Produce random bounds based on region type
+    if tag == REGION_TYPE.DOMAIN
+        % Domain
+        L = ceil(minDimension + rand * (maxDimension - minDimension));
+        bounds = [zeros(1, 3); L * ones(1, 3)];
+    else
+        % Obstacle
+
+        % Produce a corners that are contained in the domain
+        ii = 0;
+        candidateMaxCorner = domain.maxCorner + ones(1, 3);
+        candidateMinCorner = domain.minCorner - ones(1, 3);
+        % Continue until the domain contains the obstacle without crowding the objective
+        while ~domain.contains(candidateMaxCorner) || all(domain.objective.groundPos + domain.objective.protectedRange >= candidateMinCorner(1:2), 2) && all(domain.objective.groundPos - domain.objective.protectedRange <= candidateMaxCorner(1:2), 2)
+            if ii == 0 || ii > 10
+                candidateMinCorner = domain.random();
+                candidateMinCorner(3) = 0; % bind to floor
+                ii = 1;
+            end
+
+            candidateMaxCorner = candidateMinCorner + minDimension + rand(1, 3) * (maxDimension - minDimension);
+
+            ii = ii + 1;
+        end
+        
+        bounds = [candidateMinCorner; candidateMaxCorner;];
+    end
+
+    % Regular initialization
+    obj = obj.initialize(bounds, tag, label);
+end

geometries/@rectangularPrism/plotWireframe.m

@@ -0,0 +1,37 @@
+function [obj, f] = plotWireframe(obj, ind, f)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        ind (1, :) double = NaN;
+        f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
+    end
+    arguments (Output)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+        f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
+    end
+
+    % Create axes if they don't already exist
+    f = firstPlotSetup(f);
+
+    % Create plotting inputs from vertices and edges
+    X = [obj.vertices(obj.edges(:,1),1), obj.vertices(obj.edges(:,2),1)]';
+    Y = [obj.vertices(obj.edges(:,1),2), obj.vertices(obj.edges(:,2),2)]';
+    Z = [obj.vertices(obj.edges(:,1),3), obj.vertices(obj.edges(:,2),3)]';
+
+    % Plot the boundaries of the geometry into 3D view
+    if isnan(ind)
+        o = plot3(f.CurrentAxes, X, Y, Z, '-', 'Color', obj.tag.color, 'LineWidth', 2);
+    else
+        hold(f.Children(1).Children(ind(1)), "on");
+        o = plot3(f.Children(1).Children(ind(1)), X, Y, Z, '-', 'Color', obj.tag.color, 'LineWidth', 2);
+        hold(f.Children(1).Children(ind(1)), "off");
+    end
+
+    % Copy to other requested tiles
+    if numel(ind) > 1
+        for ii = 2:size(ind, 2)
+            o = [o, copyobj(o(:, 1), f.Children(1).Children(ind(ii)))];
+        end
+    end
+
+    obj.lines = o;
+end

geometries/@rectangularPrism/random.m

@@ -0,0 +1,9 @@
+function r = random(obj)
+    arguments (Input)
+        obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
+    end
+    arguments (Output)
+        r (1, 3) double
+    end
+    r = (obj.vertices(1, 1:3) + rand(1, 3) .* obj.vertices(8, 1:3) - obj.vertices(1, 1:3))';
+end

geometries/@rectangularPrism/rectangularPrism.m

@@ -0,0 +1,38 @@
+classdef rectangularPrism
+    % Rectangular prism geometry
+    properties (SetAccess = private, GetAccess = public)
+        % Meta
+        tag = REGION_TYPE.INVALID;
+        label = "";
+
+        % Spatial
+        minCorner = NaN(1, 3);
+        maxCorner = NaN(1, 3);
+        dimensions = NaN(1, 3);
+        center = NaN;
+        footprint = NaN(4, 2);
+
+        % Graph
+        vertices = NaN(8, 3);
+        edges = [1 2; 2 3; 3 4; 4 1;  % bottom square
+            5 6; 6 8; 8 7; 7 5;  % top square
+            1 5; 2 6; 3 8; 4 7]; % vertical edges
+
+        % Plotting
+        lines;
+    end
+    properties (SetAccess = public, GetAccess = public)
+        % Sensing objective (for DOMAIN region type only)
+        objective;
+    end
+
+    methods (Access = public)
+        [obj   ] = initialize(obj, bounds, tag, label, objectiveFunction, discretizationStep);
+        [obj   ] = initializeRandom(obj, tag, label, minDimension, maxDimension, domain);
+        [r     ] = random(obj);
+        [c     ] = contains(obj, pos);
+        [d     ] = distance(obj, pos);
+        [c     ] = containsLine(obj, pos1, pos2);
+        [obj, f] = plotWireframe(obj, ind, f);
+    end
+end

geometries/REGION_TYPE.m

@@ -8,6 +8,7 @@ classdef REGION_TYPE
         DOMAIN (1, [0, 0, 0]); % domain region
         OBSTACLE (2, [255, 127, 127]); % obstacle region
         COLLISION (3, [255, 255, 128]); % collision avoidance region
+        FOV (4, [255, 165, 0]); % field of view region
     end
     methods
         function obj = REGION_TYPE(id, color)

geometries/rectangularPrism.m

@@ -1,200 +0,0 @@
-classdef rectangularPrism
-    % Rectangular prism geometry
-    properties (SetAccess = private, GetAccess = public)
-        % Meta
-        tag = REGION_TYPE.INVALID;
-        label = "";
-
-        % Spatial
-        minCorner = NaN(1, 3);
-        maxCorner = NaN(1, 3);
-        dimensions = NaN(1, 3);
-        center = NaN;
-        footprint = NaN(4, 2);
-
-        % Graph
-        vertices = NaN(8, 3);
-        edges = [1 2; 2 3; 3 4; 4 1;  % bottom square
-            5 6; 6 8; 8 7; 7 5;  % top square
-            1 5; 2 6; 3 8; 4 7]; % vertical edges
-
-        % Plotting
-        lines;
-    end
-
-    methods (Access = public)
-        function obj = initialize(obj, bounds, tag, label)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                bounds (2, 3) double;
-                tag (1, 1) REGION_TYPE = REGION_TYPE.INVALID;
-                label (1, 1) string = "";
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-            end
-
-            obj.tag = tag;
-            obj.label = label;
-
-            %% Define geometry bounds by LL corner and UR corner
-            obj.minCorner = bounds(1, 1:3);
-            obj.maxCorner = bounds(2, 1:3);
-
-            % Compute L, W, H
-            obj.dimensions = [obj.maxCorner(1) - obj.minCorner(1), obj.maxCorner(2) - obj.minCorner(2), obj.maxCorner(3) - obj.minCorner(3)];
-
-            % Compute center
-            obj.center = obj.minCorner + obj.dimensions ./ 2;
-
-            % Compute vertices
-            obj.vertices = [obj.minCorner;
-                            obj.maxCorner(1), obj.minCorner(2:3);
-                            obj.maxCorner(1:2), obj.minCorner(3);
-                            obj.minCorner(1), obj.maxCorner(2), obj.minCorner(3);
-                            obj.minCorner(1:2), obj.maxCorner(3);
-                            obj.maxCorner(1), obj.minCorner(2), obj.maxCorner(3);
-                            obj.minCorner(1), obj.maxCorner(2:3)
-                            obj.maxCorner;];
-
-            % Compute footprint
-            obj.footprint = [obj.minCorner(1:2); ...
-                             [obj.minCorner(1), obj.maxCorner(2)]; ...
-                             [obj.maxCorner(1), obj.minCorner(2)]; ...
-                             obj.maxCorner(1:2)];
-        end
-        function r = random(obj)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-            end
-            arguments (Output)
-                r (1, 3) double
-            end
-            r = (obj.vertices(1, 1:3) + rand(1, 3) .* obj.vertices(8, 1:3) - obj.vertices(1, 1:3))';
-        end
-        function d = distance(obj, pos)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                pos (:, 3) double;
-            end
-            arguments (Output)
-                d (:, 1) double
-            end
-            assert(~obj.contains(pos), "Cannot determine distance for a point inside of the geometry");
-            
-            cPos = NaN(1, 3);
-            for ii = 1:3
-                if pos(ii) < obj.minCorner(ii)
-                    cPos(ii) = obj.minCorner(ii);
-                elseif pos(ii) > obj.maxCorner(ii)
-                    cPos(ii) = obj.maxCorner(ii);
-                else
-                    cPos(ii) = pos(ii);
-                end
-            end
-            d = norm(cPos - pos);
-        end
-        function d = interiorDistance(obj, pos)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                pos (:, 3) double;
-            end
-            arguments (Output)
-                d (:, 1) double
-            end
-            assert(obj.contains(pos), "Cannot determine interior distance for a point outside of the geometry");
-
-            % find minimum distance to any face
-            d = min([pos(1) - obj.minCorner(1), ...
-                     pos(2) - obj.minCorner(2), ...
-                     pos(3) - obj.minCorner(3), ...
-                     obj.maxCorner(1) - pos(1), ...
-                     obj.maxCorner(2) - pos(2), ...
-                     obj.maxCorner(3) - pos(3)]);
-        end
-        function c = contains(obj, pos)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                pos (:, 3) double;
-            end
-            arguments (Output)
-                c (:, 1) logical
-            end
-            c = all(pos >= repmat(obj.minCorner, size(pos, 1), 1), 2) & all(pos <= repmat(obj.maxCorner, size(pos, 1), 1), 2);
-        end
-        function c = containsLine(obj, pos1, pos2)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                pos1 (1, 3) double;
-                pos2 (1, 3) double;
-            end
-            arguments (Output)
-                c (1, 1) logical
-            end
-            
-            d = pos2 - pos1;
-
-            % edge case where the line is parallel to the geometry
-            if abs(d) < 1e-12
-                % check if it happens to start or end inside or outside of
-                % the geometry
-                if obj.contains(pos1) || obj.contains(pos2)
-                    c = true;
-                else
-                    c = false;
-                end
-                return;
-            end
-
-            tmin = -inf;        
-            tmax = inf;
-
-            % Standard case
-            for ii = 1:3
-                t1 = (obj.minCorner(ii) - pos1(ii)) / d(ii);
-                t2 = (obj.maxCorner(ii) - pos2(ii)) / d(ii);
-                tmin = max(tmin, min(t1, t2));
-                tmax = min(tmax, max(t1, t2));
-                if tmin > tmax
-                    c = false;
-                    return;
-                end
-            end
-
-            c = (tmax >= 0) && (tmin <= 1);
-        end
-        function [obj, f] = plotWireframe(obj, f)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'rectangularPrism')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Create axes if they don't already exist
-            f = firstPlotSetup(f);
-
-            % Create plotting inputs from vertices and edges
-            X = [obj.vertices(obj.edges(:,1),1), obj.vertices(obj.edges(:,2),1)]';
-            Y = [obj.vertices(obj.edges(:,1),2), obj.vertices(obj.edges(:,2),2)]';
-            Z = [obj.vertices(obj.edges(:,1),3), obj.vertices(obj.edges(:,2),3)]';
-
-            % Plot the boundaries of the geometry
-            hold(f.CurrentAxes, "on");
-            o = plot3(X, Y, Z, '-', 'Color', obj.tag.color, 'LineWidth', 2);
-            hold(f.CurrentAxes, "off");
-
-            % Check if this is a tiled layout figure
-            if strcmp(f.Children(1).Type, 'tiledlayout')
-                % Add to other perspectives
-                o = [o, copyobj(o(:, 1), f.Children(1).Children(2))];
-                o = [o, copyobj(o(:, 1), f.Children(1).Children(3))];
-                o = [o, copyobj(o(:, 1), f.Children(1).Children(5))];
-            end
-
-            obj.lines = o;
-        end
-    end
-end

guidanceModels/gradientAscent.m

@@ -0,0 +1,26 @@
+function nextPos = gradientAscent(sensedValues, sensedPositions, pos, rate)
+    arguments (Input)
+        sensedValues (:, 1) double;
+        sensedPositions (:, 3) double;
+        pos (1, 3) double;
+        rate (1, 1) double = 0.1;
+    end
+    arguments (Output)
+        nextPos(1, 3) double;
+    end
+
+    % As a default, maintain current position
+    if size(sensedValues, 1) == 0 && size(sensedPositions, 1) == 0
+        nextPos = pos;
+        return;
+    end
+    
+    % Select next position by maximum sensed value
+    nextPos = sensedPositions(sensedValues == max(sensedValues), :);
+    nextPos = [nextPos(1, 1:2), pos(3)]; % just in case two get selected, simply pick one
+
+    % rate-limit motion
+    v = nextPos - pos;
+    nextPos = pos + (v / norm(v, 2)) * rate;
+
+end

miSim.m

@@ -1,268 +0,0 @@
-classdef miSim
-    % multiagent interconnection simulation
-
-    % Simulation parameters
-    properties (SetAccess = private, GetAccess = public)
-        timestep = NaN; % delta time interval for simulation iterations
-        maxIter = NaN; % maximum number of simulation iterations
-        domain = rectangularPrism;
-        objective = sensingObjective;
-        obstacles = cell(0, 1); % geometries that define obstacles within the domain
-        agents = cell(0, 1); % agents that move within the domain
-        adjacency = NaN; % Adjacency matrix representing communications network graph
-    end
-
-    properties (Access = private)
-        v = VideoWriter(fullfile('sandbox', strcat(string(datetime('now'), 'yyyy_MM_dd_HH_mm_ss'), '_miSimHist')));
-        connectionsPlot; % objects for lines connecting agents in spatial plots
-        graphPlot; % objects for abstract network graph plot
-    end
-
-    methods (Access = public)
-        function [obj, f] = initialize(obj, domain, objective, agents, timestep, maxIter, obstacles)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                domain (1, 1) {mustBeGeometry};
-                objective (1, 1) {mustBeA(objective, 'sensingObjective')};
-                agents (:, 1) cell {mustBeAgents};
-                timestep (:, 1) double = 0.05;
-                maxIter (:, 1) double = 1000;
-                obstacles (:, 1) cell {mustBeGeometry} = cell(0, 1);
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Define simulation time parameters
-            obj.timestep = timestep;
-            obj.maxIter = maxIter;
-
-            % Define domain
-            obj.domain = domain;
-
-            % Add geometries representing obstacles within the domain
-            obj.obstacles = obstacles;
-
-            % Define objective
-            obj.objective = objective;
-
-            % Define agents
-            obj.agents = agents;
-
-            % Compute adjacency matrix
-            obj = obj.updateAdjacency();
-
-            % Set up initial plot
-            % Set up axes arrangement
-            % Plot domain
-            [obj.domain, f] = obj.domain.plotWireframe();
-
-            % Set plotting limits to focus on the domain
-            xlim([obj.domain.minCorner(1), obj.domain.maxCorner(1)]);
-            ylim([obj.domain.minCorner(2), obj.domain.maxCorner(2)]);
-            zlim([obj.domain.minCorner(3), obj.domain.maxCorner(3)]);
-
-            % Plot obstacles
-            for ii = 1:size(obj.obstacles, 1)
-                [obj.obstacles{ii}, f] = obj.obstacles{ii}.plotWireframe(f);
-            end
-
-            % Plot objective gradient
-            f = obj.objective.plot(f);
-
-            % Plot agents and their collision geometries
-            for ii = 1:size(obj.agents, 1)
-                [obj.agents{ii}, f] = obj.agents{ii}.plot(f);
-            end
-
-            % Plot communication links
-            [obj, f] = obj.plotConnections(f);
-
-            % Plot abstract network graph
-            [obj, f] = obj.plotGraph(f);
-        end
-        function [obj, f] = run(obj, f)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Create axes if they don't already exist
-            f = firstPlotSetup(f);
-
-            % Set up times to iterate over
-            times = linspace(0, obj.timestep * obj.maxIter, obj.maxIter+1)';
-
-            % Start video writer
-            obj.v.FrameRate = 1/obj.timestep;
-            obj.v.Quality = 90;
-            obj.v.open();
-
-            for ii = 1:size(times, 1)
-                % Display current sim time
-                t = times(ii);
-                fprintf("Sim Time: %4.2f (%d/%d)\n", t, ii, obj.maxIter)
-
-                % Iterate over agents to simulate their motion
-                for jj = 1:size(obj.agents, 1)
-                    obj.agents{jj} = obj.agents{jj}.run(obj.objective.objectiveFunction, obj.domain);
-                end
-    
-                % Update adjacency matrix
-                obj = obj.updateAdjacency;
-    
-                % Update plots
-                [obj, f] = obj.updatePlots(f);
-
-                % Write frame in to video
-                I = getframe(f);
-                obj.v.writeVideo(I);
-            end
-
-            % Close video file
-            obj.v.close();
-        end
-        function [obj, f] = updatePlots(obj, f)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Update agent positions, collision geometries
-            for ii = 1:size(obj.agents, 1)
-                obj.agents{ii}.updatePlots();
-            end
-
-            % The remaining updates might be possible to do in a clever way
-            % that moves existing lines instead of clearing and 
-            % re-plotting, which is much better for performance boost
-
-            % Update agent connections plot
-            delete(obj.connectionsPlot);
-            [obj, f] = obj.plotConnections(f);
-
-            % Update network graph plot
-            delete(obj.graphPlot);
-            [obj, f] = obj.plotGraph(f);
-
-            drawnow;
-        end
-        function obj = updateAdjacency(obj)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-            end
-
-            % Initialize assuming only self-connections
-            A = logical(eye(size(obj.agents, 1)));
-
-            % Check lower triangle off-diagonal connections
-            for ii = 2:size(A, 1)
-                for jj = 1:(ii - 1)
-                    if norm(obj.agents{ii}.pos - obj.agents{jj}.pos) <= min([obj.agents{ii}.comRange, obj.agents{jj}.comRange])
-                        % Make sure that obstacles don't obstruct the line
-                        % of sight, breaking the connection
-                        for kk = 1:size(obj.obstacles, 1)
-                            if ~obj.obstacles{kk}.containsLine(obj.agents{ii}.pos, obj.agents{jj}.pos)
-                                A(ii, jj) = true;
-                            end
-                        end
-                    end
-                end
-            end
-
-            obj.adjacency = A | A';
-        end
-        function [obj, f] = plotConnections(obj, f)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Iterate over lower triangle off-diagonal region of the 
-            % adjacency matrix to plot communications links between agents
-            X = []; Y = []; Z = [];
-            for ii = 2:size(obj.adjacency, 1)
-                for jj = 1:(ii - 1)
-                    if obj.adjacency(ii, jj)
-                        X = [X; obj.agents{ii}.pos(1), obj.agents{jj}.pos(1)];
-                        Y = [Y; obj.agents{ii}.pos(2), obj.agents{jj}.pos(2)];
-                        Z = [Z; obj.agents{ii}.pos(3), obj.agents{jj}.pos(3)];
-                    end
-                end
-            end
-            X = X'; Y = Y'; Z = Z';
-
-            % Plot the connections
-            hold(f.CurrentAxes, "on");
-            o = plot3(X, Y, Z, 'Color', 'g', 'LineWidth', 2, 'LineStyle', '--');
-            hold(f.CurrentAxes, "off");
-
-            % Check if this is a tiled layout figure
-            if strcmp(f.Children(1).Type, 'tiledlayout')
-                % Add to other plots
-                o = [o, copyobj(o(:, 1), f.Children(1).Children(2))];
-                o = [o, copyobj(o(:, 1), f.Children(1).Children(3))];
-                o = [o, copyobj(o(:, 1), f.Children(1).Children(5))];
-            end
-
-            obj.connectionsPlot = o;
-        end
-        function [obj, f] = plotGraph(obj, f)
-            arguments (Input)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')} = figure;
-            end
-            arguments (Output)
-                obj (1, 1) {mustBeA(obj, 'miSim')};
-                f (1, 1) {mustBeA(f, 'matlab.ui.Figure')};
-            end
-
-            % Form graph from adjacency matrix
-            G = graph(obj.adjacency, 'omitselfloops');
-
-            % Plot graph object
-            obj.graphPlot = plot(f.Children(1).Children(4), G, 'LineStyle', '--', 'EdgeColor', 'g', 'NodeColor', 'k', 'LineWidth', 2);
-        end
-    end
-
-    methods (Access = private)
-        function validateInitialization(obj)
-            % Assert obstacles do not intersect with the domain
-
-            % Assert obstacles do not intersect with each other
-
-            % Assert the objective has only one maxima within the domain
-
-            % Assert the objective's sole maximum is not inaccessible due
-            % to the placement of an obstacle
-
-        end
-        function validateLoop(obj)
-            % Assert that agents are safely inside the domain
-
-            % Assert that agents are not in proximity to obstacles
-
-            % Assert that agents are not in proximity to each other
-
-            % Assert that agents form a connected graph
-
-
-        end
-    end
-end

resources/project/5Gd2vBPGMN40pl5okl2ZJVqegNM/gZWQ_GaNEEy28d0iAoPpVyZFQrwp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="mustBeSensor.m" type="File"/>

resources/project/9ucwbDs2BkA9ZqIHQI_XVIGSH5A/r541J80LBY7p-VdF-2cmu2pJyd4p.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="@fixedCardinalSensor" type="File"/>

resources/project/9ucwbDs2BkA9ZqIHQI_XVIGSH5A/svhNcplUM7n23Qjwql1uZ5L6c6sp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="@sigmoidSensor" type="File"/>

resources/project/E2mMq2X73DyjKhlQAouGqrsyLgg/21tPnJuFct8IF0xfcC8JtR_tiLYd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/E2mMq2X73DyjKhlQAouGqrsyLgg/21tPnJuFct8IF0xfcC8JtR_tiLYp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="1" type="DIR_SIGNIFIER"/>

resources/project/E2mMq2X73DyjKhlQAouGqrsyLgg/TdZ3RWRwXT8LuGLEIsWOhzCcLzcd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/CCiVFlEZGOWF8RpyKjlFUC_OrW4d.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info Ref="util/validators" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/CCiVFlEZGOWF8RpyKjlFUC_OrW4p.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="1bb12f2e-385b-41a4-83e8-f9a9326d95ee" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/Lzv9PNrakrESxUF7UZmIf8m-ri4d.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info Ref="sensingFunctions" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/Lzv9PNrakrESxUF7UZmIf8m-ri4p.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info location="9c9ce3cb-5989-41e8-a20d-358a95c08b20" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/QAWdSKdcuP9OGm_S2NybPkCBTOYd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info Ref="test" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/QAWdSKdcuP9OGm_S2NybPkCBTOYp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="89c37511-fb1f-420e-919a-c5b38c02b501" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/QCjAM-pfjkxuIc0-mouM97I9zHEd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info Ref="util/validators/arguments" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/QCjAM-pfjkxuIc0-mouM97I9zHEp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="30f974f9-50a8-405c-9a83-e7fd84333f0e" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/XCp_6IVryeT94420M1370QjM5u4d.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info Ref="guidanceModels" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/XCp_6IVryeT94420M1370QjM5u4p.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="1d8d2b42-2863-4985-9cf2-980917971eba" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/bC9JguT7xdg6hTVY9GqmttWOU6Ud.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info Ref="validators" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/bC9JguT7xdg6hTVY9GqmttWOU6Up.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info location="5f96e524-3aac-4fa1-95df-67fd6ce02ff3" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/jjRWXxv1fmTGw_ntc54vNxAyLDMd.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info Ref="validators/arguments" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/jjRWXxv1fmTGw_ntc54vNxAyLDMp.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info location="b7c7eec5-a318-4c17-adb2-b13a21bf0609" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/ohKqyO-2hbPx9f-0yqpBSUUQdsgd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info Ref="sensorModels" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/ohKqyO-2hbPx9f-0yqpBSUUQdsgp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="d143c27d-6824-4569-9093-8150b60976cb" type="Reference"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/s5udZfVFP9-PGBZPOy6PEk_nJDEd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info Ref="util" Type="Relative"/>

resources/project/EEtUlUb-dLAdf0KpMVivaUlztwA/s5udZfVFP9-PGBZPOy6PEk_nJDEp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="2e3f60de-3b82-4ad5-af81-57781353dcbf" type="Reference"/>

resources/project/FI0gxbH-PhwjE_riDQGHPyYMHks/5Lk_HLOyBtA13ybsC7_0l8N5sPcd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/FI0gxbH-PhwjE_riDQGHPyYMHks/5Lk_HLOyBtA13ybsC7_0l8N5sPcp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="1" type="DIR_SIGNIFIER"/>

resources/project/FI0gxbH-PhwjE_riDQGHPyYMHks/AmJAKvt15XQGz6JdpTsYHCBwsj0d.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info>
+    <Category UUID="FileClassCategory">
+        <Label UUID="test"/>
+    </Category>
+</Info>

resources/project/FI0gxbH-PhwjE_riDQGHPyYMHks/AmJAKvt15XQGz6JdpTsYHCBwsj0p.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="test_sigmoidSensor.m" type="File"/>

resources/project/IZmCOv6JD31mVpLELAk0ipkk3_g/Y80bFtWukuhQhZV-YQoZVwUsSd4p.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="cone.m" type="File"/>

resources/project/IZmCOv6JD31mVpLELAk0ipkk3_g/_6kRedv97kNBifq-YxMdKYmJtCwp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="plot.m" type="File"/>

resources/project/IZmCOv6JD31mVpLELAk0ipkk3_g/vvaT0-TqiGnaRLajwambyiLQ2Wwp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="initialize.m" type="File"/>

resources/project/IZmCOv6JD31mVpLELAk0ipkk3_g/zR-9c0e4RmoTUjy3irYLxJytP9cd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/IZmCOv6JD31mVpLELAk0ipkk3_g/zR-9c0e4RmoTUjy3irYLxJytP9cp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="1" type="DIR_SIGNIFIER"/>

resources/project/IkDHDbHimostG0Ka3Qk97pof68k/eU5R_sxHD3gVw76yiaPpbMUKFIkp.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info location="mustBeAgents.m" type="File"/>

resources/project/IkDHDbHimostG0Ka3Qk97pof68k/xLI7SQj40yDbM71LQ8pVZ0dWmrgp.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Info location="mustBeDcm.m" type="File"/>

resources/project/NRbCR7m2f1_2pHz6LyHrTz7eFpc/IZmCOv6JD31mVpLELAk0ipkk3_gd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/NRbCR7m2f1_2pHz6LyHrTz7eFpc/IZmCOv6JD31mVpLELAk0ipkk3_gp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="@cone" type="File"/>

resources/project/NRbCR7m2f1_2pHz6LyHrTz7eFpc/tBBDcBPWdBTCTMSBG9IGJ_TsICkd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/NRbCR7m2f1_2pHz6LyHrTz7eFpc/tBBDcBPWdBTCTMSBG9IGJ_TsICkp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="@rectangularPrism" type="File"/>

resources/project/SIL3u_W39LwE7HHYsarfFmr9gVQ/0lSq9ZcW6wGcu05HTGCManxXSWgp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="updateAdjacency.m" type="File"/>

resources/project/SIL3u_W39LwE7HHYsarfFmr9gVQ/4XyMCGilNSTkYZYCWT4IaoSxyRQd.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info/>

resources/project/SIL3u_W39LwE7HHYsarfFmr9gVQ/4XyMCGilNSTkYZYCWT4IaoSxyRQp.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Info location="1" type="DIR_SIGNIFIER"/>