RoundRect contains

src/core/SkRRect.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRRect.h"
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 98 matching lines @@
     }
 
     // At this point we're either oval, simple, or complex (not empty or rect)
     // but we lazily resolve the type to avoid the work if the information
     // isn't required.
     fType = (SkRRect::Type) kUnknown_Type;
 
     SkDEBUGCODE(this->validate();)
 }
 
-bool SkRRect::contains(SkScalar x, SkScalar y) const {
+namespace {
+
+bool loose_contains(const SkRect& rect, SkScalar x, SkScalar y) {
+    return  !rect.isEmpty() &&
+            rect.fLeft <= x && x <= rect.fRight && 
+            rect.fTop <= y && y <= rect.fBottom;
+}
+
+};
+
+bool SkRRect::contains(SkScalar x, SkScalar y, bool loose) const {
     SkDEBUGCODE(this->validate();)
 
     if (kEmpty_Type == this->type()) {
         return false;
     }
 
-    if (!fRect.contains(x, y)) {
-        return false;
+    if (loose) {
+        // points on the left and right edges of a rect have a slightly 
+        // different containment definition (since they technically aren't
+        // "in" the rect)
+        if (!loose_contains(fRect, x, y)) {
+            return false;
+        }
+    } else {
+        if (!fRect.contains(x, y)) {
+            return false;
+        }
     }
 
     if (kRect_Type == this->type()) {
         // the 'fRect' test above was sufficient
         return true;
     }
 
     // We know the point is inside the RR's bounds. The only way it can
     // be out is if it outside one of the corners
     SkPoint canonicalPt; // (x,y) translated to one of the quadrants
@@ skipping 33 matching lines @@
             SkASSERT(canonicalPt.fX > 0 && canonicalPt.fY > 0);
         } else {
             // not in any of the corners
             return true;
         }
     }
 
     // A point is in an ellipse (in standard position) if:
     //      x^2     y^2
     //     ----- + ----- <= 1
     //      a^2     b^2

[jvanverth1, 2013/04/24 15:29:30]

This can be rewritten as b^2*x^2 + a^2*y^2 <= (ab)^2, which would be faster. I
guess the only precision issue might be if a and b are large, but I wouldn't
expect them to be larger than 1024 -- and in that case you might have problems
dividing by a large number.

[robertphillips, 2013/04/24 16:11:57]

Done.

     SkScalar dist =  SkScalarDiv(SkScalarSquare(canonicalPt.fX), SkScalarSquare(fRadii[index].fX)) +
                      SkScalarDiv(SkScalarSquare(canonicalPt.fY), SkScalarSquare(fRadii[index].fY));
     return dist <= SK_Scalar1;
 }
 
+bool SkRRect::contains(const SkRect& rect) const {
+    if (!this->getBounds().contains(rect)) {
+        // If 'rect' isn't contained by the RR's bounds then the
+        // RR definitely doesn't contain it
+        return false;
+    }
+
+    if (this->isRect()) {
+        // the prior test was sufficient
+        return true;
+    }
+

[jvanverth1, 2013/04/24 15:29:30]

You're checking to see if the corners are in the boundrect twice -- once above
(implictly in getBounds().contains(rect)) and then once for each point below. 
It'd be faster if you just check the  corners against the ovals once you know
the whole rect is in the boundrect. I think you could get rid of the loose
contains as well in that case.

[robertphillips, 2013/04/24 16:11:57]

Done.

+    return this->contains(rect.fLeft, rect.fTop, false) &&
+           this->contains(rect.fRight, rect.fTop, true) &&
+           this->contains(rect.fRight, rect.fBottom, true) &&
+           this->contains(rect.fLeft, rect.fBottom, true);
+}
+
 // There is a simplified version of this method in setRectXY
 void SkRRect::computeType() const {
     SkDEBUGCODE(this->validate();)
 
     if (fRect.isEmpty()) {
         fType = kEmpty_Type;
         return;
     }
 
     bool allRadiiEqual = true; // are all x radii equal and all y radii?
@@ skipping 126 matching lines @@
             SkASSERT(!allRadiiZero && !allRadiiSame && !allCornersSquare);
             break;
         case kUnknown_Type:
             // no limits on this
             break;
     }
 }
 #endif // SK_DEBUG
 
 ///////////////////////////////////////////////////////////////////////////////