Получить индексы граничных ячеек подмножества матрицы. Матлаб

Основные шаги, которые я бы использовал:

1. Выполните расширение фигуры, чтобы получить новую область, которая представляет собой форму и ее границу.
2. Вычтите исходную форму из расширенной формы, чтобы оставить только границу
3. Используйте границу для индексации матрицы данных, затем возьмите минимум.

Расширение

Что я хочу сделать здесь, так это передать окно 3x3 по каждой ячейке и взять максимальное значение в этом окне:

[m, n] = size(A); % assuming A is your original shape matrix
APadded = zeros(m + 2, n + 2);
APadded(2:end-1, 2:end-1) = A; % pad A with zeroes on each side
ADilated = zeros(m + 2, n + 2); % this will hold the dilated shape.

for i = 1:m
    for j = 1:n
        mask = zeros(size(APadded));
        mask(i:i+2, j:j+2) = 1; % this places a 3x3 square of 1's around (i, j)
        ADilated(i + 1, j + 1) = max(APadded(mask));
    end
end

Вычитание формы

Это в основном логическое И и логическое НЕ для удаления пересечения:

ABoundary = ADilated & (~APadded);

На этом этапе вы можете удалить границу, которую мы добавили для расширения, так как она нам больше не нужна.

ABoundary = ABoundary(2:end-1, 2:end-1);

Найдите минимальную точку данных вдоль границы

Мы можем использовать нашу логическую границу, чтобы индексировать исходные данные в вектор, а затем просто взять минимум этого вектора.

dataMinimum = min(data(ABoundary));

Вы должны рассматривать это как проблему морфологии, а не теории множеств. Это можно довольно легко решить с помощью imdilate() (требуется пакет изображения). В основном вам нужно только вычесть изображение до его расширения с матрицей 3x3 из 1 .

octave> test = logical ([0  0  0  0  0  0
                         0  0  0  0  0  0
                         0  0  1  1  0  0
                         0  0  1  1  0  0
                         0  0  1  1  1  1
                         0  0  1  1  1  1]);
octave> imdilate (test, true (3)) - test
ans =

   0   0   0   0   0   0
   0   1   1   1   1   0
   0   1   0   0   1   0
   0   1   0   0   1   1
   0   1   0   0   0   0
   0   1   0   0   0   0

Однако он не дополняется NaN. Если вы действительно этого хотите, вы можете дополнить исходную матрицу значением false, выполнить операцию, а затем проверить, есть ли на границе истинные значения.

Обратите внимание, что вам не обязательно использовать logical(), и в этом случае вам придется использовать ones() вместо true(). Но это занимает больше памяти и имеет худшую производительность.

EDIT: поскольку вы пытаетесь сделать это без использования какого-либо набора инструментов Matlab, взгляните на источник imdilate() в Octave. В случае логических матриц (как в вашем случае) это простое использование filter2(), которое принадлежит ядру Matlab. Тем не менее, следующая строка должна работать нормально и быть намного быстрее.

octave> (filter2 (true (3), test) > 0) - test
ans =

   0   0   0   0   0   0
   0   1   1   1   1   0
   0   1   0   0   1   0
   0   1   0   0   1   1
   0   1   0   0   0   0
   0   1   0   0   0   0

Одно из возможных решений — взять подмножество и добавить его к исходной матрице, но убедиться, что каждый раз, когда вы добавляете его, вы смещаете его позицию на +1 строку, -1 строку и +1 столбец, -1 столбец. Затем результат будет расширен на одну строку и столбец вокруг исходного подмножества. Затем вы используете исходную матрицу, чтобы замаскировать исходный подмножество до нуля.

Так:

test_new = test + ...
[[test(2:end,2:end);zeros(1,size(test,1)-1)],zeros(size(test,1),1)] + ... %move subset up-left
[[zeros(1,size(test,1)-1);test(1:end-1,2:end)],zeros(size(test,1),1)] + ... %move down-left
[zeros(size(test,1),1),[test(2:end,1:end-1);zeros(1,size(test,1)-1)]] + ... %move subset up-right
[zeros(size(test,1),1),[zeros(1,size(test,1)-1);test(1:end-1,1:end-1)]];  %move subset down-right

test_masked = test_new.*~test; %mask with original matrix
result = test_masked;
result(result>1)=1; % ensure that there is only 1's, not 2, 3, etc.

Результат для вашей матрицы test:

result =

 0     0     0     0     0     0
 0     1     1     1     1     0
 0     1     0     0     1     0
 0     1     0     0     1     1
 0     1     0     0     0     0
 0     1     0     0     0     0

Отредактировано - теперь он также захватывает углы, перемещая подмножество вверх и влево, вверх и вправо, вниз, затем влево, вниз, затем вправо.

Я ожидаю, что это будет очень быстрый способ добиться этого - в нем нет ни циклов, ни функций - только матричные операции.