ash/laser/laser_segment_utils.cc

// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/laser/laser_segment_utils.h"

#include <limits>

#include "base/logging.h"
#include "ui/gfx/geometry/point3_f.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/vector2d_f.h"
#include "ui/gfx/transform.h"

namespace ash {
namespace {

// Solves the equation x = (-b (+|-) sqrt(b^2 - 4ac)) / 2a. |use_plus|
// determines whether + or - is used in the equation; if |use_plus| is true, +
// is used. |a| cannot be 0 (linear equation). Note: This does not handle the
// case where the roots are complex.
float QuadraticEquation(bool use_plus, float a, float b, float c) {
  DCHECK_NE(0.0f, a);
  return (-1.0f * b + sqrt(b * b - 4.0f * a * c) * (use_plus ? 1.0f : -1.0f)) /
         (2.0f * a);
}
}

float AngleOfPointInNewCoordinates(const gfx::PointF& origin,
                                   const gfx::Vector2dF& direction,
                                   const gfx::PointF& point) {
  double angle_degrees = atan2(direction.y(), direction.x()) * 180.0f / M_PI;
  gfx::Transform transform;
  transform.Rotate(-angle_degrees);
  transform.Translate(-origin.x(), -origin.y());
  gfx::Point3F point_to_transform(point.x(), point.y(), 0.0f);
  transform.TransformPoint(&point_to_transform);
  return atan2(point_to_transform.y(), point_to_transform.x());
}

void ComputeNormalLineVariables(const gfx::PointF& start_point,
                                const gfx::PointF& end_point,
                                float* normal_slope,
                                float* start_y_intercept,
                                float* end_y_intercept) {
  float rise = end_point.y() - start_point.y();
  float run = end_point.x() - start_point.x();
  // If the rise of line between the two points is close to zero, the normal of
  // the line is undefined.
  if (fabs(rise) < 0.0001f) {
    *normal_slope = std::numeric_limits<float>::quiet_NaN();
    *start_y_intercept = std::numeric_limits<float>::quiet_NaN();
    *end_y_intercept = std::numeric_limits<float>::quiet_NaN();
    return;
  }

  *normal_slope = -1.0f * (run / rise);
  *start_y_intercept = start_point.y() - *normal_slope * start_point.x();
  *end_y_intercept = end_point.y() - *normal_slope * end_point.x();
}

void ComputeProjectedPoints(const gfx::PointF& point,
                            float line_slope,
                            float line_y_intercept,
                            float projection_distance,
                            gfx::PointF* first_projection,
                            gfx::PointF* second_projection) {
  // If the slope is NaN, the y-intercept should be NaN too. The line is thus
  // vertical and projections will be projected straight up/down from |point|.
  if (isnan(line_slope)) {
    DCHECK(isnan(line_y_intercept));

    *first_projection =
        gfx::PointF(point.x(), point.y() + round(projection_distance));
    *second_projection =
        gfx::PointF(point.x(), point.y() - round(projection_distance));
    return;
  }

  // |point| must be on the line defined by |line_slope| and |line_y_intercept|.
  DCHECK_LE(fabs(point.y() - (line_slope * point.x() + line_y_intercept)), 2.f);

  // We want the two points along the line given by |slope|(m) and
  // |y_intercept|(b). If |original_point| is defined as (x,y) and
  // |distance_from_old_point| is d, we want the two (dx,dy) which satisfys the
  // two equations (1)dx^2+dy^2=d^2 and (2)y+dy=m(x+dx)+b. Since y,x,b and m are
  // constants we form a new equation (3)dy=mdx + K, where K=mx+b-y. Plugging
  // (3) into (1) we get dx^2+(mdx)^2+2Kmdx+K^2=d^2 ->
  // (m^2+1)dx^2+(2Km)dx+(K^2-d^2)=0. We can then solve for dx using the
  // quadratic equation with variables a=m^2+1, b=2Km, c=K^2-d^2. We plug
  // dx into (3) to find dy. The new points will then be (x+dx,y+dy).
  float constant = line_y_intercept + line_slope * point.x() - point.y();
  float a = 1.0f + line_slope * line_slope;
  float b = 2.0f * line_slope * constant;
  float c = constant * constant - projection_distance * projection_distance;
  float p1_delta_x = QuadraticEquation(true, a, b, c);
  float p1_delta_y =
      line_slope * (point.x() + p1_delta_x) + line_y_intercept - point.y();
  float p2_delta_x = QuadraticEquation(false, a, b, c);
  float p2_delta_y =
      line_slope * (point.x() + p2_delta_x) + line_y_intercept - point.y();
  *first_projection =
      gfx::PointF(point.x() + round(p1_delta_x), point.y() + round(p1_delta_y));
  *second_projection =
      gfx::PointF(point.x() + round(p2_delta_x), point.y() + round(p2_delta_y));
}

bool IsFirstPointSmallerAngle(const gfx::PointF& start_point,
                              const gfx::PointF& end_point,
                              const gfx::PointF& first_point,
                              const gfx::PointF& second_point) {
  gfx::PointF new_origin(
      start_point.x() + (end_point.x() - start_point.x()) / 2.0f,
      start_point.y() + (end_point.y() - start_point.y()) / 2.0f);
  gfx::Vector2dF direction = end_point - start_point;

  // Compute the angles of the projections relative to the the new origin and
  // direction.
  float end_first_projection_angle =
      AngleOfPointInNewCoordinates(new_origin, direction, first_point);
  float end_second_projection_angle =
      AngleOfPointInNewCoordinates(new_origin, direction, second_point);

  // We want to always have the smaller angle come first.
  return end_first_projection_angle < end_second_projection_angle;
}

}  // namespace ash