Delta analysis
Reviewed on Mar 05, 05:38
Review level:
View on GitHub
Code Health
8.14
(-0.02)Code Health Quality gate
Failed
Declining Code Health
1 finding
Improving Code Health
0 findings
Affected Hotspots
0 Files
Authors
Declining Code Health
1 FINDINGS
(1 type in 1 file)Complex Method
control/mpc_lateral_controller/src/mpc_lateral_controller.cpp: MpcLateralController::run
Suppress finding
What lead to degradation?
MpcLateralController::run increases in cyclomatic complexity from 10 to 12, threshold = 9
Why does this problem occur?
A Complex Method has a high cyclomatic complexity. The recommended threshold for the C++ language is a cyclomatic complexity lower than 9.
How to fix it?
There are many reasons for Complex Method. Sometimes, another design approach is beneficial such as a) modeling state using an explicit state machine rather than conditionals, or b) using table lookup rather than long chains of logic. In other scenarios, the function can be split using EXTRACT FUNCTION. Just make sure you extract natural and cohesive functions. Complex Methods can also be addressed by identifying complex conditional expressions and then using the DECOMPOSE CONDITIONAL refactoring.
Helpful refactoring examples
This code health issue has been solved before in this project. Here are some examples for inspiration:
| @@ -13,5 +13,2 @@ |
| // limitations under the License. |
| // |
| // |
| // Author: v1.0 Yukihiro Saito, Taekjin Lee |
| @@ -69,7 +66,5 @@ double get2dIoU( |
| const auto source_polygon = autoware_utils::to_polygon2d( |
| source_object.kinematics.pose_with_covariance.pose, source_object.shape); |
| const auto source_polygon = autoware_utils::to_polygon2d(source_object.pose, source_object.shape); |
| if (boost::geometry::area(source_polygon) < MIN_AREA) return 0.0; |
| const auto target_polygon = autoware_utils::to_polygon2d( |
| target_object.kinematics.pose_with_covariance.pose, target_object.shape); |
| const auto target_polygon = autoware_utils::to_polygon2d(target_object.pose, target_object.shape); |
| if (boost::geometry::area(target_polygon) < MIN_AREA) return 0.0; |
| @@ -113,6 +108,4 @@ bool convertConvexHullToBoundingBox( |
| // calc new center |
| const Eigen::Vector2d center{ |
| input_object.kinematics.pose_with_covariance.pose.position.x, |
| input_object.kinematics.pose_with_covariance.pose.position.y}; |
| const auto yaw = tf2::getYaw(input_object.kinematics.pose_with_covariance.pose.orientation); |
| const Eigen::Vector2d center{input_object.pose.position.x, input_object.pose.position.y}; |
| const auto yaw = tf2::getYaw(input_object.pose.orientation); |
| const Eigen::Matrix2d R_inv = Eigen::Rotation2Dd(-yaw).toRotationMatrix(); |
| @@ -123,4 +116,4 @@ bool convertConvexHullToBoundingBox( |
| output_object = input_object; |
| output_object.kinematics.pose_with_covariance.pose.position.x = new_center.x(); |
| output_object.kinematics.pose_with_covariance.pose.position.y = new_center.y(); |
| output_object.pose.position.x = new_center.x(); |
| output_object.pose.position.y = new_center.y(); |
| @@ -137,3 +130,3 @@ bool getMeasurementYaw( |
| { |
| measurement_yaw = tf2::getYaw(object.kinematics.pose_with_covariance.pose.orientation); |
| measurement_yaw = tf2::getYaw(object.pose.orientation); |
| @@ -180,6 +173,11 @@ enum BBOX_IDX { |
| */ |
| int getNearestCornerOrSurface( |
| const double x, const double y, const double yaw, const double width, const double length, |
| const geometry_msgs::msg::Transform & self_transform) |
| void getNearestCornerOrSurface( |
| const geometry_msgs::msg::Transform & self_transform, types::DynamicObject & object) |
| { |
| const double x = object.pose.position.x; |
| const double y = object.pose.position.y; |
| const double yaw = tf2::getYaw(object.pose.orientation); |
| const double width = object.shape.dimensions.y; |
| const double length = object.shape.dimensions.x; |
| // get local vehicle pose |
| @@ -193,3 +191,3 @@ int getNearestCornerOrSurface( |
| // Determine Index |
| // Determine anchor point |
| // x+ (front) |
| @@ -200,104 +198,57 @@ int getNearestCornerOrSurface( |
| // x- (rear) |
| int xgrid = 0; |
| int ygrid = 0; |
| const int labels[3][3] = { |
| {BBOX_IDX::FRONT_L_CORNER, BBOX_IDX::FRONT_SURFACE, BBOX_IDX::FRONT_R_CORNER}, |
| {BBOX_IDX::LEFT_SURFACE, BBOX_IDX::INSIDE, BBOX_IDX::RIGHT_SURFACE}, |
| {BBOX_IDX::REAR_L_CORNER, BBOX_IDX::REAR_SURFACE, BBOX_IDX::REAR_R_CORNER}}; |
| double anchor_x = 0; |
| double anchor_y = 0; |
| if (xl > length / 2.0) { |
| xgrid = 0; // front |
| anchor_x = length / 2.0; |
| } else if (xl > -length / 2.0) { |
| xgrid = 1; // middle |
| anchor_x = 0; |
| } else { |
| xgrid = 2; // rear |
| anchor_x = -length / 2.0; |
| } |
| if (yl > width / 2.0) { |
| ygrid = 0; // left |
| anchor_y = width / 2.0; |
| } else if (yl > -width / 2.0) { |
| ygrid = 1; // middle |
| anchor_y = 0; |
| } else { |
| ygrid = 2; // right |
| anchor_y = -width / 2.0; |
| } |
| return labels[xgrid][ygrid]; // 0 to 7 + 1(null) value |
| } |
| /** |
| * @brief Calc bounding box center offset caused by shape change |
| * @param dw: width update [m] = w_new - w_old |
| * @param dl: length update [m] = l_new - l_old |
| * @param indx: nearest corner index |
| * @return 2d offset vector caused by shape change |
| */ |
| inline Eigen::Vector2d calcOffsetVectorFromShapeChange( |
| const double dw, const double dl, const int indx) |
| { |
| Eigen::Vector2d offset; |
| // if surface |
| if (indx == BBOX_IDX::FRONT_SURFACE) { |
| offset(0, 0) = dl / 2.0; // move forward |
| offset(1, 0) = 0; |
| } else if (indx == BBOX_IDX::RIGHT_SURFACE) { |
| offset(0, 0) = 0; |
| offset(1, 0) = -dw / 2.0; // move right |
| } else if (indx == BBOX_IDX::REAR_SURFACE) { |
| offset(0, 0) = -dl / 2.0; // move backward |
| offset(1, 0) = 0; |
| } else if (indx == BBOX_IDX::LEFT_SURFACE) { |
| offset(0, 0) = 0; |
| offset(1, 0) = dw / 2.0; // move left |
| } |
| // if corner |
| if (indx == BBOX_IDX::FRONT_R_CORNER) { |
| offset(0, 0) = dl / 2.0; // move forward |
| offset(1, 0) = -dw / 2.0; // move right |
| } else if (indx == BBOX_IDX::REAR_R_CORNER) { |
| offset(0, 0) = -dl / 2.0; // move backward |
| offset(1, 0) = -dw / 2.0; // move right |
| } else if (indx == BBOX_IDX::REAR_L_CORNER) { |
| offset(0, 0) = -dl / 2.0; // move backward |
| offset(1, 0) = dw / 2.0; // move left |
| } else if (indx == BBOX_IDX::FRONT_L_CORNER) { |
| offset(0, 0) = dl / 2.0; // move forward |
| offset(1, 0) = dw / 2.0; // move left |
| } |
| return offset; // do nothing if indx == INVALID or INSIDE |
| object.anchor_point.x = anchor_x; |
| object.anchor_point.y = anchor_y; |
| } |
| /** |
| * @brief Convert input object center to tracking point based on nearest corner information |
| * 1. update anchor offset vector, 2. offset input bbox based on tracking_offset vector and |
| * prediction yaw angle |
| * @param w: last input bounding box width |
| * @param l: last input bounding box length |
| * @param indx: last input bounding box closest corner index |
| * @param input_object: input object bounding box |
| * @param yaw: current yaw estimation |
| * @param offset_object: output tracking measurement to feed ekf |
| * @return nearest corner index(int) |
| */ |
| void calcAnchorPointOffset( |
| const double w, const double l, const int indx, const types::DynamicObject & input_object, |
| const double & yaw, types::DynamicObject & offset_object, Eigen::Vector2d & tracking_offset) |
| const types::DynamicObject & this_object, Eigen::Vector2d & tracking_offset, |
| types::DynamicObject & updating_object) |
| { |
| // copy value |
| offset_object = input_object; |
| // invalid index |
| if (indx == BBOX_IDX::INSIDE) { |
| return; // do nothing |
| const geometry_msgs::msg::Point anchor_vector = updating_object.anchor_point; |
| // invalid anchor |
| if (anchor_vector.x <= 1e-6 && anchor_vector.y <= 1e-6) { |
| return; |
| } |
| double input_yaw = tf2::getYaw(updating_object.pose.orientation); |
| // current object width and height |
| const double w_n = input_object.shape.dimensions.y; |
| const double l_n = input_object.shape.dimensions.x; |
| const double length = this_object.shape.dimensions.x; |
| const double width = this_object.shape.dimensions.y; |
| // update offset |
| const Eigen::Vector2d offset = calcOffsetVectorFromShapeChange(w_n - w, l_n - l, indx); |
| tracking_offset = offset; |
| tracking_offset = Eigen::Vector2d(anchor_vector.x, anchor_vector.y); |
| if (tracking_offset.x() > 0) { |
| tracking_offset.x() -= length / 2.0; |
| } else if (tracking_offset.x() < 0) { |
| tracking_offset.x() += length / 2.0; |
| } |
| if (tracking_offset.y() > 0) { |
| tracking_offset.y() -= width / 2.0; |
| } else if (tracking_offset.y() < 0) { |
| tracking_offset.y() += width / 2.0; |
| } |
| // offset input object |
| const Eigen::Matrix2d R = Eigen::Rotation2Dd(yaw).toRotationMatrix(); |
| const Eigen::Matrix2d R = Eigen::Rotation2Dd(input_yaw).toRotationMatrix(); |
| const Eigen::Vector2d rotated_offset = R * tracking_offset; |
| offset_object.kinematics.pose_with_covariance.pose.position.x += rotated_offset.x(); |
| offset_object.kinematics.pose_with_covariance.pose.position.y += rotated_offset.y(); |
| updating_object.pose.position.x += rotated_offset.x(); |
| updating_object.pose.position.y += rotated_offset.y(); |
| } |