I am sorry, I do not understand your question. Please show more details of code you have tried and where it is not working.

thanks,
Doug

Do you want me to tell you or do you like me to keep this as an added problem to solve?

I think that if you try to prove in a rigorous way that your algorithm always finds the largest rectangle you will probably realize that it doesn’t.

I tried the above code. It does not work for me. I looks to me like the logic test:

% Eliminate boxes which contain points
for i = 1:length(box_i)
	points_outside = (tree.x=box_right(box_i(i)) |...
                     tree.y=box_top(box_i(i)));
    if all(points_outside)
        break % Found a good one
    end
end

Is implemented incorrectly. You are only checking for top and right, but not bottom and left. Also, the single equals sign is an assignment, I think you wanted a greater than. Once I added the other checks, I found that this finds a valid rectangle, but never the best one. I think the reason for that is the “indexing into something that indexes into something else” is done incorrectly.

I think these changes can be fixed, but a simpler scheme might make it easier to avoid such errors.

-Doug

Yes, I had an inkling of the same conclusion, but did not pursue it. My original outline on paper proposed something like that, but I wanted to keep it simple. I often find that I will compromise: taking simplicity over efficiency and then continue to optimize from there. Since this algorithm works, I stopped. If the inefficiency started to matter, that would be the lowest hanging fruit to go after.

What I like about MATLAB is that it is pretty easy to prototype ideas. I can afford to throw this together, see how it works and then iterate on my code because it is fast to program.

-Thanks,
Doug

The proposed algorithm will find the largest area twice using the scenario from the video. Had there been three trees inside the bounding box that enclosed the largesty area I believe it would be found 3 times. This sounds somewhat inefficient. Could one device a check inside the algoritm that stops once the largest area is found the first time?

A little white-board scetching tells me that once you start subdividing around the second tree, if an area contains the first tree than you can immediately stop because if there is an interesting area there, then it has allready been found. This should trivially extend to N trees.

Anyone have a comment on my reasoning here?

–DA

function [bigArea, boundBox] = main(trees)
% find largest field; short but uses O(n^4) memory
%% find bigArea
[bigArea, boundBox] = deal(struct('x',[],'y',[],'width',[],'height',[]));
boundBox.x = min(trees.x);
boundBox.y = min(trees.y);
boundBox.width = max(trees.x) - boundBox.x;
boundBox.height = max(trees.y) - boundBox.y;
%% find area of every possible field
% Consider every possible combination of X and Y coordinates
n = numel(trees.x);
% Construct an [n x n] array of all possible field widths
delX = bsxfun(@minus, trees.x, shiftdim(trees.x, -1));
% Construct an [n x n] array of all possible field heights
delY = bsxfun(@minus, trees.y, shiftdim(trees.y, -1));
% Construct an [n x n x n x n] array of all possible field areas
area = bsxfun(@times, delX, shiftdim(delY, -2));
% Sort the areas, largest to smallest
[areaSort, iSort] = sort(area(:), 'descend');
% Look for the largest area that contains no trees
for i=iSort'
    % Convert the sorted index to subscripts
    % (subscripts correspond to indices in tree.x and tree.y)
    [x1,x2,y1,y2] = ind2sub([n,n,n,n], i);
    if ~any(trees.x > min(trees.x([x1 x2])) & ...
            trees.x < max(trees.x([x1 x2])) & ...
            trees.y > min(trees.y([y1 y2])) & ...
            trees.y < max(trees.y([y1 y2])) )
        break % this area has no trees
    end
end
%% Record results
bigArea.x = min(trees.x([x1 x2]));
bigArea.y = min(trees.y([y1 y2]));
bigArea.width = abs(diff(trees.x([x1 x2])));
bigArea.height = abs(diff(trees.y([y1 y2])));
end % function main