ui/gfx/path_mac_unittest.mm - cobalt - Git at Google

 // 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.

 #import "ui/gfx/path_mac.h"

 #include <cmath>
 #include <vector>

 #import <Cocoa/Cocoa.h>

 #include "base/check_op.h"
 #include "base/cxx17_backports.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"

 namespace gfx {

 namespace {

 // Returns the point at a distance of |radius| from the point (|centre_x|,
 // |centre_y|), and angle |degrees| from the positive horizontal axis, measured
 // anti-clockwise.
 NSPoint GetRadialPoint(double radius,
                        double degrees,
                        double centre_x,
                        double centre_y) {
   const double radian = (degrees * SK_ScalarPI) / 180;
   return NSMakePoint(centre_x + radius * std::cos(radian),
                      centre_y + radius * std::sin(radian));
 }

 // Returns the area of a circle with the given |radius|.
 double CalculateCircleArea(double radius) {
   return SK_ScalarPI * radius * radius;
 }

 // Returns the area of a simple polygon. |path| should represent a simple
 // polygon.
 double CalculatePolygonArea(NSBezierPath* path) {
   // If path represents a single polygon, it will have MoveTo, followed by
   // multiple LineTo, followed By ClosePath, followed by another MoveTo
   // NSBezierPathElement.
   const size_t element_count = [path elementCount];
   NSPoint points[3];
   std::vector<NSPoint> poly;

   for (size_t i = 0; i < element_count - 1; i++) {
     NSBezierPathElement element =
         [path elementAtIndex:i associatedPoints:points];
     poly.push_back(points[0]);
     DCHECK_EQ(element,
               i ? (i == element_count - 2 ? NSClosePathBezierPathElement
                                           : NSLineToBezierPathElement)
                 : NSMoveToBezierPathElement);
   }
   DCHECK_EQ([path elementAtIndex:element_count - 1], NSMoveToBezierPathElement);

   // Shoelace Algorithm to find the area of a simple polygon.
   DCHECK(NSEqualPoints(poly.front(), poly.back()));
   double area = 0;
   for (size_t i = 0; i < poly.size() - 1; i++)
     area += poly[i].x * poly[i + 1].y - poly[i].y * poly[i + 1].x;

   return std::fabs(area) / 2.0;
 }

 // Returns the area of a rounded rectangle with the given |width|, |height| and
 // |radius|.
 double CalculateRoundedRectangleArea(double width,
                                      double height,
                                      double radius) {
   const double inside_width = width - 2 * radius;
   const double inside_height = height - 2 * radius;
   return inside_width * inside_height +
          2 * radius * (inside_width + inside_height) +
          CalculateCircleArea(radius);
 }

 // Returns the bounding box of |path| as a Rect.
 Rect GetBoundingBox(NSBezierPath* path) {
   const NSRect bounds = [path bounds];
   return ToNearestRect(RectF(bounds.origin.x, bounds.origin.y,
                              bounds.size.width, bounds.size.height));
 }

 }  // namespace

 // Check that empty NSBezierPath is returned for empty SkPath.
 TEST(CreateNSBezierPathFromSkPathTest, EmptyPath) {
   NSBezierPath* result = CreateNSBezierPathFromSkPath(SkPath());
   EXPECT_TRUE([result isEmpty]);
 }

 // Check that the returned NSBezierPath has the correct winding rule.
 TEST(CreateNSBezierPathFromSkPathTest, FillType) {
   SkPath path;
   path.setFillType(SkPathFillType::kWinding);
   NSBezierPath* result = CreateNSBezierPathFromSkPath(path);
   EXPECT_EQ(NSNonZeroWindingRule, [result windingRule]);

   path.setFillType(SkPathFillType::kEvenOdd);
   result = CreateNSBezierPathFromSkPath(path);
   EXPECT_EQ(NSEvenOddWindingRule, [result windingRule]);
 }

 // Check that a path containing multiple subpaths, in this case two rectangles,
 // is correctly converted to a NSBezierPath.
 TEST(CreateNSBezierPathFromSkPathTest, TwoRectanglesPath) {
   const SkRect rects[] = {
       {0, 0, 50, 50}, {100, 100, 150, 150},
   };
   const NSPoint inside_points[] = {
       {1, 1},     {1, 49},    {49, 49},   {49, 1},    {25, 25},
       {101, 101}, {101, 149}, {149, 149}, {149, 101}, {125, 125}};
   const NSPoint outside_points[] = {{-1, -1}, {-1, 51},  {51, 51},   {51, -1},
                                     {99, 99}, {99, 151}, {151, 151}, {151, 99},
                                     {75, 75}, {-5, -5}};
   ASSERT_EQ(base::size(inside_points), base::size(outside_points));
   const Rect expected_bounds(0, 0, 150, 150);

   SkPath path;
   path.addRect(rects[0]);
   path.addRect(rects[1]);
   NSBezierPath* result = CreateNSBezierPathFromSkPath(path);

   // Check points near the boundary of the path and verify that they are
   // reported correctly as being inside/outside the path.
   for (size_t i = 0; i < base::size(inside_points); i++) {
     EXPECT_TRUE([result containsPoint:inside_points[i]]);
     EXPECT_FALSE([result containsPoint:outside_points[i]]);
   }

   // Check that the returned result has the correct bounding box. GetBoundingBox
   // rounds the coordinates to nearest integer values.
   EXPECT_EQ(expected_bounds, GetBoundingBox(result));
 }

 // Test that an SKPath containing a circle is converted correctly to a
 // NSBezierPath.
 TEST(CreateNSBezierPathFromSkPathTest, CirclePath) {
   const int kRadius = 5;
   const int kCentreX = 10;
   const int kCentreY = 15;
   const double kCushion = 0.1;
   // Expected bounding box of the circle.
   const Rect expected_bounds(kCentreX - kRadius, kCentreY - kRadius,
                              2 * kRadius, 2 * kRadius);

   SkPath path;
   path.addCircle(SkIntToScalar(kCentreX), SkIntToScalar(kCentreY),
                  SkIntToScalar(kRadius));
   NSBezierPath* result = CreateNSBezierPathFromSkPath(path);

   // Check points near the boundary of the circle and verify that they are
   // reported correctly as being inside/outside the path.
   for (size_t deg = 0; deg < 360; deg++) {
     NSPoint inside_point =
         GetRadialPoint(kRadius - kCushion, deg, kCentreX, kCentreY);
     NSPoint outside_point =
         GetRadialPoint(kRadius + kCushion, deg, kCentreX, kCentreY);
     EXPECT_TRUE([result containsPoint:inside_point]);
     EXPECT_FALSE([result containsPoint:outside_point]);
   }

   // Check that the returned result has the correct bounding box. GetBoundingBox
   // rounds the coordinates to nearest integer values.
   EXPECT_EQ(expected_bounds, GetBoundingBox(result));

   // Check area of converted path is correct up to a certain tolerance value. To
   // find the area of the NSBezierPath returned, flatten it i.e. convert it to a
   // polygon.
   [NSBezierPath setDefaultFlatness:0.01];
   NSBezierPath* polygon = [result bezierPathByFlatteningPath];
   const double kTolerance = 0.14;
   EXPECT_NEAR(CalculateCircleArea(kRadius), CalculatePolygonArea(polygon),
               kTolerance);
 }

 // Test that an SKPath containing a rounded rectangle is converted correctly to
 // a NSBezierPath.
 TEST(CreateNSBezierPathFromSkPathTest, RoundedRectanglePath) {
   const int kRectangleWidth = 50;
   const int kRectangleHeight = 100;
   const int kCornerRadius = 5;
   const double kCushion = 0.1;
   // Expected bounding box of the rounded rectangle.
   const Rect expected_bounds(kRectangleWidth, kRectangleHeight);

   SkRRect rrect;
   rrect.setRectXY(SkRect::MakeWH(kRectangleWidth, kRectangleHeight),
                   kCornerRadius, kCornerRadius);

   const NSPoint inside_points[] = {
       // Bottom left corner.
       {kCornerRadius / 2.0, kCornerRadius / 2.0},
       // Bottom right corner.
       {kRectangleWidth - kCornerRadius / 2.0, kCornerRadius / 2.0},
       // Top Right corner.
       {kRectangleWidth - kCornerRadius / 2.0,
        kRectangleHeight - kCornerRadius / 2.0},
       // Top left corner.
       {kCornerRadius / 2.0, kRectangleHeight - kCornerRadius / 2.0},
       // Bottom middle.
       {kRectangleWidth / 2.0, kCushion},
       // Right middle.
       {kRectangleWidth - kCushion, kRectangleHeight / 2.0},
       // Top middle.
       {kRectangleWidth / 2.0, kRectangleHeight - kCushion},
       // Left middle.
       {kCushion, kRectangleHeight / 2.0}};
   const NSPoint outside_points[] = {
       // Bottom left corner.
       {0, 0},
       // Bottom right corner.
       {kRectangleWidth, 0},
       // Top right corner.
       {kRectangleWidth, kRectangleHeight},
       // Top left corner.
       {0, kRectangleHeight},
       // Bottom middle.
       {kRectangleWidth / 2.0, -kCushion},
       // Right middle.
       {kRectangleWidth + kCushion, kRectangleHeight / 2.0},
       // Top middle.
       {kRectangleWidth / 2.0, kRectangleHeight + kCushion},
       // Left middle.
       {-kCushion, kRectangleHeight / 2.0}};
   ASSERT_EQ(base::size(inside_points), base::size(outside_points));

   SkPath path;
   path.addRRect(rrect);
   NSBezierPath* result = CreateNSBezierPathFromSkPath(path);

   // Check points near the boundary of the path and verify that they are
   // reported correctly as being inside/outside the path.
   for (size_t i = 0; i < base::size(inside_points); i++) {
     EXPECT_TRUE([result containsPoint:inside_points[i]]);
     EXPECT_FALSE([result containsPoint:outside_points[i]]);
   }

   // Check that the returned result has the correct bounding box. GetBoundingBox
   // rounds the coordinates to nearest integer values.
   EXPECT_EQ(expected_bounds, GetBoundingBox(result));

   // Check area of converted path is correct up to a certain tolerance value. To
   // find the area of the NSBezierPath returned, flatten it i.e. convert it to a
   // polygon.
   [NSBezierPath setDefaultFlatness:0.01];
   NSBezierPath* polygon = [result bezierPathByFlatteningPath];
   const double kTolerance = 0.14;
   EXPECT_NEAR(CalculateRoundedRectangleArea(kRectangleWidth, kRectangleHeight,
                                             kCornerRadius),
               CalculatePolygonArea(polygon), kTolerance);
 }

 }  // namespace gfx
	// 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.

	#import "ui/gfx/path_mac.h"

	#include <cmath>
	#include <vector>

	#import <Cocoa/Cocoa.h>

	#include "base/check_op.h"
	#include "base/cxx17_backports.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/skia/include/core/SkPath.h"
	#include "third_party/skia/include/core/SkRegion.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/geometry/rect_conversions.h"

	namespace gfx {

	namespace {

	// Returns the point at a distance of \|radius\| from the point (\|centre_x\|,
	// \|centre_y\|), and angle \|degrees\| from the positive horizontal axis, measured
	// anti-clockwise.
	NSPoint GetRadialPoint(double radius,
	double degrees,
	double centre_x,
	double centre_y) {
	const double radian = (degrees * SK_ScalarPI) / 180;
	return NSMakePoint(centre_x + radius * std::cos(radian),
	centre_y + radius * std::sin(radian));
	}

	// Returns the area of a circle with the given \|radius\|.
	double CalculateCircleArea(double radius) {
	return SK_ScalarPI * radius * radius;
	}

	// Returns the area of a simple polygon. \|path\| should represent a simple
	// polygon.
	double CalculatePolygonArea(NSBezierPath* path) {
	// If path represents a single polygon, it will have MoveTo, followed by
	// multiple LineTo, followed By ClosePath, followed by another MoveTo
	// NSBezierPathElement.
	const size_t element_count = [path elementCount];
	NSPoint points[3];
	std::vector<NSPoint> poly;

	for (size_t i = 0; i < element_count - 1; i++) {
	NSBezierPathElement element =
	[path elementAtIndex:i associatedPoints:points];
	poly.push_back(points[0]);
	DCHECK_EQ(element,
	i ? (i == element_count - 2 ? NSClosePathBezierPathElement
	: NSLineToBezierPathElement)
	: NSMoveToBezierPathElement);
	}
	DCHECK_EQ([path elementAtIndex:element_count - 1], NSMoveToBezierPathElement);

	// Shoelace Algorithm to find the area of a simple polygon.
	DCHECK(NSEqualPoints(poly.front(), poly.back()));
	double area = 0;
	for (size_t i = 0; i < poly.size() - 1; i++)
	area += poly[i].x * poly[i + 1].y - poly[i].y * poly[i + 1].x;

	return std::fabs(area) / 2.0;
	}

	// Returns the area of a rounded rectangle with the given \|width\|, \|height\| and
	// \|radius\|.
	double CalculateRoundedRectangleArea(double width,
	double height,
	double radius) {
	const double inside_width = width - 2 * radius;
	const double inside_height = height - 2 * radius;
	return inside_width * inside_height +
	2 * radius * (inside_width + inside_height) +
	CalculateCircleArea(radius);
	}

	// Returns the bounding box of \|path\| as a Rect.
	Rect GetBoundingBox(NSBezierPath* path) {
	const NSRect bounds = [path bounds];
	return ToNearestRect(RectF(bounds.origin.x, bounds.origin.y,
	bounds.size.width, bounds.size.height));
	}

	} // namespace

	// Check that empty NSBezierPath is returned for empty SkPath.
	TEST(CreateNSBezierPathFromSkPathTest, EmptyPath) {
	NSBezierPath* result = CreateNSBezierPathFromSkPath(SkPath());
	EXPECT_TRUE([result isEmpty]);
	}

	// Check that the returned NSBezierPath has the correct winding rule.
	TEST(CreateNSBezierPathFromSkPathTest, FillType) {
	SkPath path;
	path.setFillType(SkPathFillType::kWinding);
	NSBezierPath* result = CreateNSBezierPathFromSkPath(path);
	EXPECT_EQ(NSNonZeroWindingRule, [result windingRule]);

	path.setFillType(SkPathFillType::kEvenOdd);
	result = CreateNSBezierPathFromSkPath(path);
	EXPECT_EQ(NSEvenOddWindingRule, [result windingRule]);
	}

	// Check that a path containing multiple subpaths, in this case two rectangles,
	// is correctly converted to a NSBezierPath.
	TEST(CreateNSBezierPathFromSkPathTest, TwoRectanglesPath) {
	const SkRect rects[] = {
	{0, 0, 50, 50}, {100, 100, 150, 150},
	};
	const NSPoint inside_points[] = {
	{1, 1}, {1, 49}, {49, 49}, {49, 1}, {25, 25},
	{101, 101}, {101, 149}, {149, 149}, {149, 101}, {125, 125}};
	const NSPoint outside_points[] = {{-1, -1}, {-1, 51}, {51, 51}, {51, -1},
	{99, 99}, {99, 151}, {151, 151}, {151, 99},
	{75, 75}, {-5, -5}};
	ASSERT_EQ(base::size(inside_points), base::size(outside_points));
	const Rect expected_bounds(0, 0, 150, 150);

	SkPath path;
	path.addRect(rects[0]);
	path.addRect(rects[1]);
	NSBezierPath* result = CreateNSBezierPathFromSkPath(path);

	// Check points near the boundary of the path and verify that they are
	// reported correctly as being inside/outside the path.
	for (size_t i = 0; i < base::size(inside_points); i++) {
	EXPECT_TRUE([result containsPoint:inside_points[i]]);
	EXPECT_FALSE([result containsPoint:outside_points[i]]);
	}

	// Check that the returned result has the correct bounding box. GetBoundingBox
	// rounds the coordinates to nearest integer values.
	EXPECT_EQ(expected_bounds, GetBoundingBox(result));
	}

	// Test that an SKPath containing a circle is converted correctly to a
	// NSBezierPath.
	TEST(CreateNSBezierPathFromSkPathTest, CirclePath) {
	const int kRadius = 5;
	const int kCentreX = 10;
	const int kCentreY = 15;
	const double kCushion = 0.1;
	// Expected bounding box of the circle.
	const Rect expected_bounds(kCentreX - kRadius, kCentreY - kRadius,
	2 * kRadius, 2 * kRadius);

	SkPath path;
	path.addCircle(SkIntToScalar(kCentreX), SkIntToScalar(kCentreY),
	SkIntToScalar(kRadius));
	NSBezierPath* result = CreateNSBezierPathFromSkPath(path);

	// Check points near the boundary of the circle and verify that they are
	// reported correctly as being inside/outside the path.
	for (size_t deg = 0; deg < 360; deg++) {
	NSPoint inside_point =
	GetRadialPoint(kRadius - kCushion, deg, kCentreX, kCentreY);
	NSPoint outside_point =
	GetRadialPoint(kRadius + kCushion, deg, kCentreX, kCentreY);
	EXPECT_TRUE([result containsPoint:inside_point]);
	EXPECT_FALSE([result containsPoint:outside_point]);
	}

	// Check that the returned result has the correct bounding box. GetBoundingBox
	// rounds the coordinates to nearest integer values.
	EXPECT_EQ(expected_bounds, GetBoundingBox(result));

	// Check area of converted path is correct up to a certain tolerance value. To
	// find the area of the NSBezierPath returned, flatten it i.e. convert it to a
	// polygon.
	[NSBezierPath setDefaultFlatness:0.01];
	NSBezierPath* polygon = [result bezierPathByFlatteningPath];
	const double kTolerance = 0.14;
	EXPECT_NEAR(CalculateCircleArea(kRadius), CalculatePolygonArea(polygon),
	kTolerance);
	}

	// Test that an SKPath containing a rounded rectangle is converted correctly to
	// a NSBezierPath.
	TEST(CreateNSBezierPathFromSkPathTest, RoundedRectanglePath) {
	const int kRectangleWidth = 50;
	const int kRectangleHeight = 100;
	const int kCornerRadius = 5;
	const double kCushion = 0.1;
	// Expected bounding box of the rounded rectangle.
	const Rect expected_bounds(kRectangleWidth, kRectangleHeight);

	SkRRect rrect;
	rrect.setRectXY(SkRect::MakeWH(kRectangleWidth, kRectangleHeight),
	kCornerRadius, kCornerRadius);

	const NSPoint inside_points[] = {
	// Bottom left corner.
	{kCornerRadius / 2.0, kCornerRadius / 2.0},
	// Bottom right corner.
	{kRectangleWidth - kCornerRadius / 2.0, kCornerRadius / 2.0},
	// Top Right corner.
	{kRectangleWidth - kCornerRadius / 2.0,
	kRectangleHeight - kCornerRadius / 2.0},
	// Top left corner.
	{kCornerRadius / 2.0, kRectangleHeight - kCornerRadius / 2.0},
	// Bottom middle.
	{kRectangleWidth / 2.0, kCushion},
	// Right middle.
	{kRectangleWidth - kCushion, kRectangleHeight / 2.0},
	// Top middle.
	{kRectangleWidth / 2.0, kRectangleHeight - kCushion},
	// Left middle.
	{kCushion, kRectangleHeight / 2.0}};
	const NSPoint outside_points[] = {
	// Bottom left corner.
	{0, 0},
	// Bottom right corner.
	{kRectangleWidth, 0},
	// Top right corner.
	{kRectangleWidth, kRectangleHeight},
	// Top left corner.
	{0, kRectangleHeight},
	// Bottom middle.
	{kRectangleWidth / 2.0, -kCushion},
	// Right middle.
	{kRectangleWidth + kCushion, kRectangleHeight / 2.0},
	// Top middle.
	{kRectangleWidth / 2.0, kRectangleHeight + kCushion},
	// Left middle.
	{-kCushion, kRectangleHeight / 2.0}};
	ASSERT_EQ(base::size(inside_points), base::size(outside_points));

	SkPath path;
	path.addRRect(rrect);
	NSBezierPath* result = CreateNSBezierPathFromSkPath(path);

	// Check points near the boundary of the path and verify that they are
	// reported correctly as being inside/outside the path.
	for (size_t i = 0; i < base::size(inside_points); i++) {
	EXPECT_TRUE([result containsPoint:inside_points[i]]);
	EXPECT_FALSE([result containsPoint:outside_points[i]]);
	}

	// Check that the returned result has the correct bounding box. GetBoundingBox
	// rounds the coordinates to nearest integer values.
	EXPECT_EQ(expected_bounds, GetBoundingBox(result));

	// Check area of converted path is correct up to a certain tolerance value. To
	// find the area of the NSBezierPath returned, flatten it i.e. convert it to a
	// polygon.
	[NSBezierPath setDefaultFlatness:0.01];
	NSBezierPath* polygon = [result bezierPathByFlatteningPath];
	const double kTolerance = 0.14;
	EXPECT_NEAR(CalculateRoundedRectangleArea(kRectangleWidth, kRectangleHeight,
	kCornerRadius),
	CalculatePolygonArea(polygon), kTolerance);
	}

	} // namespace gfx