Box blur dev #55
Open
Box blur dev #55
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
ConnorNeed
reviewed
Jan 19, 2026
Member
ConnorNeed
left a comment
ConnorNeed
left a comment
There was a problem hiding this comment.
Great work! Good use of header documentation. Your implemtation file could use less redundant comments.
| return false; | ||
| } | ||
|
|
||
| if (radius_ < 0) { |
Member
There was a problem hiding this comment.
Suggested change
| if (radius_ < 0) { | |
| if (radius_ <= 0) { |
| mapOut.add(this->outputLayer_); | ||
| mapOutHorz.add(this->outputLayer_); | ||
|
|
||
| HorizontalBoxBlur(mapIn[inputLayer_], mapOutHorz[outputLayer_], radius_); //Blurs input layer from mapIn horizontally, saves blurred values to mapOutHorz on outputLayer_ |
Member
There was a problem hiding this comment.
Unnecessary comment. If future coders need to understand what that function does they should look at the header file
| mapOutHorz.add(this->outputLayer_); | ||
|
|
||
| HorizontalBoxBlur(mapIn[inputLayer_], mapOutHorz[outputLayer_], radius_); //Blurs input layer from mapIn horizontally, saves blurred values to mapOutHorz on outputLayer_ | ||
| VerticalBoxBlur(mapOutHorz[outputLayer_], mapOut[outputLayer_], radius_); //Blurs outputLayer_ from mapOutHorz vertically, saves blurred values to mapOut on outputLayer_ |
|
|
||
| HorizontalBoxBlur(mapIn[inputLayer_], mapOutHorz[outputLayer_], radius_); //Blurs input layer from mapIn horizontally, saves blurred values to mapOutHorz on outputLayer_ | ||
| VerticalBoxBlur(mapOutHorz[outputLayer_], mapOut[outputLayer_], radius_); //Blurs outputLayer_ from mapOutHorz vertically, saves blurred values to mapOut on outputLayer_ | ||
| //Box blur complete! |
Member
There was a problem hiding this comment.
It is generally assumed that when a function returns it is complete.
| //ensuring that max and min cells in radius do not exceed dimensions of gridmap layer | ||
| int minCoeff = std::max(0, x - r); | ||
| int maxCoeff = std::min(width - 1, x + r); | ||
| int numHoles = 0; |
Member
There was a problem hiding this comment.
Generally you want to count what you are interested in. We don't really care about the number of holes. We care about the number of valid values. I would rename this to be numValues.
| } | ||
|
|
||
| template <typename T> | ||
| void BoxBlurFilter<T>::VerticalBoxBlur(const Eigen::MatrixXf &layerIn, Eigen::MatrixXf &layerOut, int r) |
Member
There was a problem hiding this comment.
Same comments apply as above
| template <typename T> | ||
| void BoxBlurFilter<T>::HorizontalBoxBlur(const Eigen::MatrixXf &layerIn, Eigen::MatrixXf &layerOut, int r) | ||
| { | ||
| int height = layerOut.rows(); |
Member
There was a problem hiding this comment.
Suggested change
| int height = layerOut.rows(); | |
| const int height = layerOut.rows(); |
| void BoxBlurFilter<T>::HorizontalBoxBlur(const Eigen::MatrixXf &layerIn, Eigen::MatrixXf &layerOut, int r) | ||
| { | ||
| int height = layerOut.rows(); | ||
| int width = layerOut.cols(); |
Member
There was a problem hiding this comment.
Suggested change
| int width = layerOut.cols(); | |
| const int width = layerOut.cols(); |
| for (int y = 0; y < height; y++) { | ||
| for (int x = 0; x < width; x++) { | ||
| //ensuring that max and min cells in radius do not exceed dimensions of gridmap layer | ||
| int minCoeff = std::max(0, x - r); |
Member
There was a problem hiding this comment.
Suggested change
| int minCoeff = std::max(0, x - r); | |
| const int minCoeff = std::max(0, x - r); |
| for (int x = 0; x < width; x++) { | ||
| //ensuring that max and min cells in radius do not exceed dimensions of gridmap layer | ||
| int minCoeff = std::max(0, x - r); | ||
| int maxCoeff = std::min(width - 1, x + r); |
Member
There was a problem hiding this comment.
Suggested change
| int maxCoeff = std::min(width - 1, x + r); | |
| const int maxCoeff = std::min(width - 1, x + r); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
What:
Created a new box blur filter that can be applied to a gridmap layer to assist the rover in determining the traversability of terrain by smoothing over noise and holes.
Why:
The built-in box blur function the rover had been using previously was inefficient, so this new algorithm was created with the intention of reducing latency.
How:
This increased efficiency is achieved by using a separable algorithm in place of the naive implementation that was used previously. The gridmap layer inputLayer_ of mapIn is first blurred along the horizontal axis, and then blurred again, vertically before being returned in mapOut as outputLayer_. The function also takes in a blur radius (in units of cells, not distance), which is typically set to one but can be expanded.
Testing:
This code has been tested using the Jetson and the Zed camera, and the results have been compared against the old algorithm to find that they produce highly similar results (with the only differences being found along the edge of the map depending on what mode the old algorithm's edge handling was set to).
Other Notes:
Any potentially unclear lines should be commented in the code, but do let me know if there's anything I need to clarify.
In the future, it would be possible to use weighted averages during the blurring process in order to achieve a Gaussian blur as opposed to a box blur (unweighted) were that to become necessary.