src/core/SkRRect.cpp - skia.git - Git at Google

 /*
  * 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 "SkRRectPriv.h"
 #include "SkBuffer.h"
 #include "SkMalloc.h"
 #include "SkMatrix.h"
 #include "SkScaleToSides.h"

 #include <cmath>
 #include <utility>

 ///////////////////////////////////////////////////////////////////////////////

 void SkRRect::setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad) {
     if (!this->initializeRect(rect)) {
         return;
     }

     if (!SkScalarsAreFinite(xRad, yRad)) {
         xRad = yRad = 0;    // devolve into a simple rect
     }

     if (fRect.width() < xRad+xRad || fRect.height() < yRad+yRad) {
         // At most one of these two divides will be by zero, and neither numerator is zero.
         SkScalar scale = SkMinScalar(sk_ieee_float_divide(fRect. width(), xRad + xRad),
                                      sk_ieee_float_divide(fRect.height(), yRad + yRad));
         SkASSERT(scale < SK_Scalar1);
         xRad *= scale;
         yRad *= scale;
     }

     if (xRad <= 0 || yRad <= 0) {
         // all corners are square in this case
         this->setRect(rect);
         return;
     }

     for (int i = 0; i < 4; ++i) {
         fRadii[i].set(xRad, yRad);
     }
     fType = kSimple_Type;
     if (xRad >= SkScalarHalf(fRect.width()) && yRad >= SkScalarHalf(fRect.height())) {
         fType = kOval_Type;
         // TODO: assert that all the x&y radii are already W/2 & H/2
     }

     SkASSERT(this->isValid());
 }

 void SkRRect::setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
                            SkScalar rightRad, SkScalar bottomRad) {
     if (!this->initializeRect(rect)) {
         return;
     }

     const SkScalar array[4] = { leftRad, topRad, rightRad, bottomRad };
     if (!SkScalarsAreFinite(array, 4)) {
         this->setRect(rect);    // devolve into a simple rect
         return;
     }

     leftRad = SkMaxScalar(leftRad, 0);
     topRad = SkMaxScalar(topRad, 0);
     rightRad = SkMaxScalar(rightRad, 0);
     bottomRad = SkMaxScalar(bottomRad, 0);

     SkScalar scale = SK_Scalar1;
     if (leftRad + rightRad > fRect.width()) {
         scale = fRect.width() / (leftRad + rightRad);
     }
     if (topRad + bottomRad > fRect.height()) {
         scale = SkMinScalar(scale, fRect.height() / (topRad + bottomRad));
     }

     if (scale < SK_Scalar1) {
         leftRad *= scale;
         topRad *= scale;
         rightRad *= scale;
         bottomRad *= scale;
     }

     if (leftRad == rightRad && topRad == bottomRad) {
         if (leftRad >= SkScalarHalf(fRect.width()) && topRad >= SkScalarHalf(fRect.height())) {
             fType = kOval_Type;
         } else if (0 == leftRad || 0 == topRad) {
             // If the left and (by equality check above) right radii are zero then it is a rect.
             // Same goes for top/bottom.
             fType = kRect_Type;
             leftRad = 0;
             topRad = 0;
             rightRad = 0;
             bottomRad = 0;
         } else {
             fType = kSimple_Type;
         }
     } else {
         fType = kNinePatch_Type;
     }

     fRadii[kUpperLeft_Corner].set(leftRad, topRad);
     fRadii[kUpperRight_Corner].set(rightRad, topRad);
     fRadii[kLowerRight_Corner].set(rightRad, bottomRad);
     fRadii[kLowerLeft_Corner].set(leftRad, bottomRad);

     SkASSERT(this->isValid());
 }

 // These parameters intentionally double. Apropos crbug.com/463920, if one of the
 // radii is huge while the other is small, single precision math can completely
 // miss the fact that a scale is required.
 static double compute_min_scale(double rad1, double rad2, double limit, double curMin) {
     if ((rad1 + rad2) > limit) {
         return SkTMin(curMin, limit / (rad1 + rad2));
     }
     return curMin;
 }

 static bool clamp_to_zero(SkVector radii[4]) {
     bool allCornersSquare = true;

     // Clamp negative radii to zero
     for (int i = 0; i < 4; ++i) {
         if (radii[i].fX <= 0 || radii[i].fY <= 0) {
             // In this case we are being a little fast & loose. Since one of
             // the radii is 0 the corner is square. However, the other radii
             // could still be non-zero and play in the global scale factor
             // computation.
             radii[i].fX = 0;
             radii[i].fY = 0;
         } else {
             allCornersSquare = false;
         }
     }

     return allCornersSquare;
 }

 void SkRRect::setRectRadii(const SkRect& rect, const SkVector radii[4]) {
     if (!this->initializeRect(rect)) {
         return;
     }

     if (!SkScalarsAreFinite(&radii[0].fX, 8)) {
         this->setRect(rect);    // devolve into a simple rect
         return;
     }

     memcpy(fRadii, radii, sizeof(fRadii));

     if (clamp_to_zero(fRadii)) {
         this->setRect(rect);
         return;
     }

     this->scaleRadii(rect);
 }

 bool SkRRect::initializeRect(const SkRect& rect) {
     // Check this before sorting because sorting can hide nans.
     if (!rect.isFinite()) {
         *this = SkRRect();
         return false;
     }
     fRect = rect.makeSorted();
     if (fRect.isEmpty()) {
         memset(fRadii, 0, sizeof(fRadii));
         fType = kEmpty_Type;
         return false;
     }
     return true;
 }

 // If we can't distinguish one of the radii relative to the other, force it to zero so it
 // doesn't confuse us later. See crbug.com/850350
 //
 static void flush_to_zero(SkScalar& a, SkScalar& b) {
     SkASSERT(a >= 0);
     SkASSERT(b >= 0);
     if (a + b == a) {
         b = 0;
     } else if (a + b == b) {
         a = 0;
     }
 }

 void SkRRect::scaleRadii(const SkRect& rect) {
     // Proportionally scale down all radii to fit. Find the minimum ratio
     // of a side and the radii on that side (for all four sides) and use
     // that to scale down _all_ the radii. This algorithm is from the
     // W3 spec (http://www.w3.org/TR/css3-background/) section 5.5 - Overlapping
     // Curves:
     // "Let f = min(Li/Si), where i is one of { top, right, bottom, left },
     //   Si is the sum of the two corresponding radii of the corners on side i,
     //   and Ltop = Lbottom = the width of the box,
     //   and Lleft = Lright = the height of the box.
     // If f < 1, then all corner radii are reduced by multiplying them by f."
     double scale = 1.0;

     // The sides of the rectangle may be larger than a float.
     double width = (double)fRect.fRight - (double)fRect.fLeft;
     double height = (double)fRect.fBottom - (double)fRect.fTop;
     scale = compute_min_scale(fRadii[0].fX, fRadii[1].fX, width,  scale);
     scale = compute_min_scale(fRadii[1].fY, fRadii[2].fY, height, scale);
     scale = compute_min_scale(fRadii[2].fX, fRadii[3].fX, width,  scale);
     scale = compute_min_scale(fRadii[3].fY, fRadii[0].fY, height, scale);

     flush_to_zero(fRadii[0].fX, fRadii[1].fX);
     flush_to_zero(fRadii[1].fY, fRadii[2].fY);
     flush_to_zero(fRadii[2].fX, fRadii[3].fX);
     flush_to_zero(fRadii[3].fY, fRadii[0].fY);

     if (scale < 1.0) {
         SkScaleToSides::AdjustRadii(width,  scale, &fRadii[0].fX, &fRadii[1].fX);
         SkScaleToSides::AdjustRadii(height, scale, &fRadii[1].fY, &fRadii[2].fY);
         SkScaleToSides::AdjustRadii(width,  scale, &fRadii[2].fX, &fRadii[3].fX);
         SkScaleToSides::AdjustRadii(height, scale, &fRadii[3].fY, &fRadii[0].fY);
     }

     // adjust radii may set x or y to zero; set companion to zero as well
     if (clamp_to_zero(fRadii)) {
         this->setRect(rect);
         return;
     }

     // At this point we're either oval, simple, or complex (not empty or rect).
     this->computeType();

     SkASSERT(this->isValid());
 }

 // This method determines if a point known to be inside the RRect's bounds is
 // inside all the corners.
 bool SkRRect::checkCornerContainment(SkScalar x, SkScalar y) const {
     SkPoint canonicalPt; // (x,y) translated to one of the quadrants
     int index;

     if (kOval_Type == this->type()) {
         canonicalPt.set(x - fRect.centerX(), y - fRect.centerY());
         index = kUpperLeft_Corner;  // any corner will do in this case
     } else {
         if (x < fRect.fLeft + fRadii[kUpperLeft_Corner].fX &&
             y < fRect.fTop + fRadii[kUpperLeft_Corner].fY) {
             // UL corner
             index = kUpperLeft_Corner;
             canonicalPt.set(x - (fRect.fLeft + fRadii[kUpperLeft_Corner].fX),
                             y - (fRect.fTop + fRadii[kUpperLeft_Corner].fY));
             SkASSERT(canonicalPt.fX < 0 && canonicalPt.fY < 0);
         } else if (x < fRect.fLeft + fRadii[kLowerLeft_Corner].fX &&
                    y > fRect.fBottom - fRadii[kLowerLeft_Corner].fY) {
             // LL corner
             index = kLowerLeft_Corner;
             canonicalPt.set(x - (fRect.fLeft + fRadii[kLowerLeft_Corner].fX),
                             y - (fRect.fBottom - fRadii[kLowerLeft_Corner].fY));
             SkASSERT(canonicalPt.fX < 0 && canonicalPt.fY > 0);
         } else if (x > fRect.fRight - fRadii[kUpperRight_Corner].fX &&
                    y < fRect.fTop + fRadii[kUpperRight_Corner].fY) {
             // UR corner
             index = kUpperRight_Corner;
             canonicalPt.set(x - (fRect.fRight - fRadii[kUpperRight_Corner].fX),
                             y - (fRect.fTop + fRadii[kUpperRight_Corner].fY));
             SkASSERT(canonicalPt.fX > 0 && canonicalPt.fY < 0);
         } else if (x > fRect.fRight - fRadii[kLowerRight_Corner].fX &&
                    y > fRect.fBottom - fRadii[kLowerRight_Corner].fY) {
             // LR corner
             index = kLowerRight_Corner;
             canonicalPt.set(x - (fRect.fRight - fRadii[kLowerRight_Corner].fX),
                             y - (fRect.fBottom - fRadii[kLowerRight_Corner].fY));
             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
     // or :
     //     b^2*x^2 + a^2*y^2 <= (ab)^2
     SkScalar dist =  SkScalarSquare(canonicalPt.fX) * SkScalarSquare(fRadii[index].fY) +
                      SkScalarSquare(canonicalPt.fY) * SkScalarSquare(fRadii[index].fX);
     return dist <= SkScalarSquare(fRadii[index].fX * fRadii[index].fY);
 }

 bool SkRRectPriv::AllCornersCircular(const SkRRect& rr, SkScalar tolerance) {
     return SkScalarNearlyEqual(rr.fRadii[0].fX, rr.fRadii[0].fY, tolerance) &&
            SkScalarNearlyEqual(rr.fRadii[1].fX, rr.fRadii[1].fY, tolerance) &&
            SkScalarNearlyEqual(rr.fRadii[2].fX, rr.fRadii[2].fY, tolerance) &&
            SkScalarNearlyEqual(rr.fRadii[3].fX, rr.fRadii[3].fY, tolerance);
 }

 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;
     }

     // At this point we know all four corners of 'rect' are inside the
     // bounds of of this RR. Check to make sure all the corners are inside
     // all the curves
     return this->checkCornerContainment(rect.fLeft, rect.fTop) &&
            this->checkCornerContainment(rect.fRight, rect.fTop) &&
            this->checkCornerContainment(rect.fRight, rect.fBottom) &&
            this->checkCornerContainment(rect.fLeft, rect.fBottom);
 }

 static bool radii_are_nine_patch(const SkVector radii[4]) {
     return radii[SkRRect::kUpperLeft_Corner].fX == radii[SkRRect::kLowerLeft_Corner].fX &&
            radii[SkRRect::kUpperLeft_Corner].fY == radii[SkRRect::kUpperRight_Corner].fY &&
            radii[SkRRect::kUpperRight_Corner].fX == radii[SkRRect::kLowerRight_Corner].fX &&
            radii[SkRRect::kLowerLeft_Corner].fY == radii[SkRRect::kLowerRight_Corner].fY;
 }

 // There is a simplified version of this method in setRectXY
 void SkRRect::computeType() {
     if (fRect.isEmpty()) {
         SkASSERT(fRect.isSorted());
         for (size_t i = 0; i < SK_ARRAY_COUNT(fRadii); ++i) {
             SkASSERT((fRadii[i] == SkVector{0, 0}));
         }
         fType = kEmpty_Type;
         SkASSERT(this->isValid());
         return;
     }

     bool allRadiiEqual = true; // are all x radii equal and all y radii?
     bool allCornersSquare = 0 == fRadii[0].fX || 0 == fRadii[0].fY;

     for (int i = 1; i < 4; ++i) {
         if (0 != fRadii[i].fX && 0 != fRadii[i].fY) {
             // if either radius is zero the corner is square so both have to
             // be non-zero to have a rounded corner
             allCornersSquare = false;
         }
         if (fRadii[i].fX != fRadii[i-1].fX || fRadii[i].fY != fRadii[i-1].fY) {
             allRadiiEqual = false;
         }
     }

     if (allCornersSquare) {
         fType = kRect_Type;
         SkASSERT(this->isValid());
         return;
     }

     if (allRadiiEqual) {
         if (fRadii[0].fX >= SkScalarHalf(fRect.width()) &&
             fRadii[0].fY >= SkScalarHalf(fRect.height())) {
             fType = kOval_Type;
         } else {
             fType = kSimple_Type;
         }
         SkASSERT(this->isValid());
         return;
     }

     if (radii_are_nine_patch(fRadii)) {
         fType = kNinePatch_Type;
     } else {
         fType = kComplex_Type;
     }
     SkASSERT(this->isValid());
 }

 bool SkRRect::transform(const SkMatrix& matrix, SkRRect* dst) const {
     if (nullptr == dst) {
         return false;
     }

     // Assert that the caller is not trying to do this in place, which
     // would violate const-ness. Do not return false though, so that
     // if they know what they're doing and want to violate it they can.
     SkASSERT(dst != this);

     if (matrix.isIdentity()) {
         *dst = *this;
         return true;
     }

     if (!matrix.preservesAxisAlignment()) {
         return false;
     }

     SkRect newRect;
     if (!matrix.mapRect(&newRect, fRect)) {
         return false;
     }

     // The matrix may have scaled us to zero (or due to float madness, we now have collapsed
     // some dimension of the rect, so we need to check for that. Note that matrix must be
     // scale and translate and mapRect() produces a sorted rect. So an empty rect indicates
     // loss of precision.
     if (!newRect.isFinite() || newRect.isEmpty()) {
         return false;
     }

     // At this point, this is guaranteed to succeed, so we can modify dst.
     dst->fRect = newRect;

     // Since the only transforms that were allowed are axis aligned, the type
     // remains unchanged.
     dst->fType = fType;

     if (kRect_Type == fType) {
         SkASSERT(dst->isValid());
         return true;
     }
     if (kOval_Type == fType) {
         for (int i = 0; i < 4; ++i) {
             dst->fRadii[i].fX = SkScalarHalf(newRect.width());
             dst->fRadii[i].fY = SkScalarHalf(newRect.height());
         }
         SkASSERT(dst->isValid());
         return true;
     }

     // Now scale each corner
     SkScalar xScale = matrix.getScaleX();
     SkScalar yScale = matrix.getScaleY();

     // There is a rotation of 90 (Clockwise 90) or 270 (Counter clockwise 90).
     // 180 degrees rotations are simply flipX with a flipY and would come under
     // a scale transform.
     if (!matrix.isScaleTranslate()) {
         const bool isClockwise = matrix.getSkewX() < 0;

         // The matrix location for scale changes if there is a rotation.
         xScale = matrix.getSkewY() * (isClockwise ? 1 : -1);
         yScale = matrix.getSkewX() * (isClockwise ? -1 : 1);

         const int dir = isClockwise ? 3 : 1;
         for (int i = 0; i < 4; ++i) {
             const int src = (i + dir) >= 4 ? (i + dir) % 4 : (i + dir);
             // Swap X and Y axis for the radii.
             dst->fRadii[i].fX = fRadii[src].fY;
             dst->fRadii[i].fY = fRadii[src].fX;
         }
     } else {
         for (int i = 0; i < 4; ++i) {
             dst->fRadii[i].fX = fRadii[i].fX;
             dst->fRadii[i].fY = fRadii[i].fY;
         }
     }

     const bool flipX = xScale < 0;
     if (flipX) {
         xScale = -xScale;
     }

     const bool flipY = yScale < 0;
     if (flipY) {
         yScale = -yScale;
     }

     // Scale the radii without respecting the flip.
     for (int i = 0; i < 4; ++i) {
         dst->fRadii[i].fX *= xScale;
         dst->fRadii[i].fY *= yScale;
     }

     // Now swap as necessary.
     using std::swap;
     if (flipX) {
         if (flipY) {
             // Swap with opposite corners
             swap(dst->fRadii[kUpperLeft_Corner], dst->fRadii[kLowerRight_Corner]);
             swap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kLowerLeft_Corner]);
         } else {
             // Only swap in x
             swap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kUpperLeft_Corner]);
             swap(dst->fRadii[kLowerRight_Corner], dst->fRadii[kLowerLeft_Corner]);
         }
     } else if (flipY) {
         // Only swap in y
         swap(dst->fRadii[kUpperLeft_Corner], dst->fRadii[kLowerLeft_Corner]);
         swap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kLowerRight_Corner]);
     }

     if (!AreRectAndRadiiValid(dst->fRect, dst->fRadii)) {
         return false;
     }

     dst->scaleRadii(dst->fRect);
     dst->isValid();

     return true;
 }

 ///////////////////////////////////////////////////////////////////////////////

 void SkRRect::inset(SkScalar dx, SkScalar dy, SkRRect* dst) const {
     SkRect r = fRect.makeInset(dx, dy);
     bool degenerate = false;
     if (r.fRight <= r.fLeft) {
         degenerate = true;
         r.fLeft = r.fRight = SkScalarAve(r.fLeft, r.fRight);
     }
     if (r.fBottom <= r.fTop) {
         degenerate = true;
         r.fTop = r.fBottom = SkScalarAve(r.fTop, r.fBottom);
     }
     if (degenerate) {
         dst->fRect = r;
         memset(dst->fRadii, 0, sizeof(dst->fRadii));
         dst->fType = kEmpty_Type;
         return;
     }
     if (!r.isFinite()) {
         *dst = SkRRect();
         return;
     }

     SkVector radii[4];
     memcpy(radii, fRadii, sizeof(radii));
     for (int i = 0; i < 4; ++i) {
         if (radii[i].fX) {
             radii[i].fX -= dx;
         }
         if (radii[i].fY) {
             radii[i].fY -= dy;
         }
     }
     dst->setRectRadii(r, radii);
 }

 ///////////////////////////////////////////////////////////////////////////////

 size_t SkRRect::writeToMemory(void* buffer) const {
     // Serialize only the rect and corners, but not the derived type tag.
     memcpy(buffer, this, kSizeInMemory);
     return kSizeInMemory;
 }

 void SkRRectPriv::WriteToBuffer(const SkRRect& rr, SkWBuffer* buffer) {
     // Serialize only the rect and corners, but not the derived type tag.
     buffer->write(&rr, SkRRect::kSizeInMemory);
 }

 size_t SkRRect::readFromMemory(const void* buffer, size_t length) {
     if (length < kSizeInMemory) {
         return 0;
     }

     SkRRect raw;
     memcpy(&raw, buffer, kSizeInMemory);
     this->setRectRadii(raw.fRect, raw.fRadii);
     return kSizeInMemory;
 }

 bool SkRRectPriv::ReadFromBuffer(SkRBuffer* buffer, SkRRect* rr) {
     if (buffer->available() < SkRRect::kSizeInMemory) {
         return false;
     }
     SkRRect storage;
     return buffer->read(&storage, SkRRect::kSizeInMemory) &&
            (rr->readFromMemory(&storage, SkRRect::kSizeInMemory) == SkRRect::kSizeInMemory);
 }

 #include "SkString.h"
 #include "SkStringUtils.h"

 void SkRRect::dump(bool asHex) const {
     SkScalarAsStringType asType = asHex ? kHex_SkScalarAsStringType : kDec_SkScalarAsStringType;

     fRect.dump(asHex);
     SkString line("const SkPoint corners[] = {\n");
     for (int i = 0; i < 4; ++i) {
         SkString strX, strY;
         SkAppendScalar(&strX, fRadii[i].x(), asType);
         SkAppendScalar(&strY, fRadii[i].y(), asType);
         line.appendf("    { %s, %s },", strX.c_str(), strY.c_str());
         if (asHex) {
             line.appendf(" /* %f %f */", fRadii[i].x(), fRadii[i].y());
         }
         line.append("\n");
     }
     line.append("};");
     SkDebugf("%s\n", line.c_str());
 }

 ///////////////////////////////////////////////////////////////////////////////

 /**
  *  We need all combinations of predicates to be true to have a "safe" radius value.
  */
 static bool are_radius_check_predicates_valid(SkScalar rad, SkScalar min, SkScalar max) {
     return (min <= max) && (rad <= max - min) && (min + rad <= max) && (max - rad >= min) &&
            rad >= 0;
 }

 bool SkRRect::isValid() const {
     if (!AreRectAndRadiiValid(fRect, fRadii)) {
         return false;
     }

     bool allRadiiZero = (0 == fRadii[0].fX && 0 == fRadii[0].fY);
     bool allCornersSquare = (0 == fRadii[0].fX || 0 == fRadii[0].fY);
     bool allRadiiSame = true;

     for (int i = 1; i < 4; ++i) {
         if (0 != fRadii[i].fX || 0 != fRadii[i].fY) {
             allRadiiZero = false;
         }

         if (fRadii[i].fX != fRadii[i-1].fX || fRadii[i].fY != fRadii[i-1].fY) {
             allRadiiSame = false;
         }

         if (0 != fRadii[i].fX && 0 != fRadii[i].fY) {
             allCornersSquare = false;
         }
     }
     bool patchesOfNine = radii_are_nine_patch(fRadii);

     if (fType < 0 || fType > kLastType) {
         return false;
     }

     switch (fType) {
         case kEmpty_Type:
             if (!fRect.isEmpty() || !allRadiiZero || !allRadiiSame || !allCornersSquare) {
                 return false;
             }
             break;
         case kRect_Type:
             if (fRect.isEmpty() || !allRadiiZero || !allRadiiSame || !allCornersSquare) {
                 return false;
             }
             break;
         case kOval_Type:
             if (fRect.isEmpty() || allRadiiZero || !allRadiiSame || allCornersSquare) {
                 return false;
             }

             for (int i = 0; i < 4; ++i) {
                 if (!SkScalarNearlyEqual(fRadii[i].fX, SkScalarHalf(fRect.width())) ||
                     !SkScalarNearlyEqual(fRadii[i].fY, SkScalarHalf(fRect.height()))) {
                     return false;
                 }
             }
             break;
         case kSimple_Type:
             if (fRect.isEmpty() || allRadiiZero || !allRadiiSame || allCornersSquare) {
                 return false;
             }
             break;
         case kNinePatch_Type:
             if (fRect.isEmpty() || allRadiiZero || allRadiiSame || allCornersSquare ||
                 !patchesOfNine) {
                 return false;
             }
             break;
         case kComplex_Type:
             if (fRect.isEmpty() || allRadiiZero || allRadiiSame || allCornersSquare ||
                 patchesOfNine) {
                 return false;
             }
             break;
     }

     return true;
 }

 bool SkRRect::AreRectAndRadiiValid(const SkRect& rect, const SkVector radii[4]) {
     if (!rect.isFinite() || !rect.isSorted()) {
         return false;
     }
     for (int i = 0; i < 4; ++i) {
         if (!are_radius_check_predicates_valid(radii[i].fX, rect.fLeft, rect.fRight) ||
             !are_radius_check_predicates_valid(radii[i].fY, rect.fTop, rect.fBottom)) {
             return false;
         }
     }
     return true;
 }
 ///////////////////////////////////////////////////////////////////////////////
	/*
	* 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 "SkRRectPriv.h"
	#include "SkBuffer.h"
	#include "SkMalloc.h"
	#include "SkMatrix.h"
	#include "SkScaleToSides.h"

	#include <cmath>
	#include <utility>

	///////////////////////////////////////////////////////////////////////////////

	void SkRRect::setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad) {
	if (!this->initializeRect(rect)) {
	return;
	}

	if (!SkScalarsAreFinite(xRad, yRad)) {
	xRad = yRad = 0; // devolve into a simple rect
	}

	if (fRect.width() < xRad+xRad \|\| fRect.height() < yRad+yRad) {
	// At most one of these two divides will be by zero, and neither numerator is zero.
	SkScalar scale = SkMinScalar(sk_ieee_float_divide(fRect. width(), xRad + xRad),
	sk_ieee_float_divide(fRect.height(), yRad + yRad));
	SkASSERT(scale < SK_Scalar1);
	xRad *= scale;
	yRad *= scale;
	}

	if (xRad <= 0 \|\| yRad <= 0) {
	// all corners are square in this case
	this->setRect(rect);
	return;
	}

	for (int i = 0; i < 4; ++i) {
	fRadii[i].set(xRad, yRad);
	}
	fType = kSimple_Type;
	if (xRad >= SkScalarHalf(fRect.width()) && yRad >= SkScalarHalf(fRect.height())) {
	fType = kOval_Type;
	// TODO: assert that all the x&y radii are already W/2 & H/2
	}

	SkASSERT(this->isValid());
	}

	void SkRRect::setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
	SkScalar rightRad, SkScalar bottomRad) {
	if (!this->initializeRect(rect)) {
	return;
	}

	const SkScalar array[4] = { leftRad, topRad, rightRad, bottomRad };
	if (!SkScalarsAreFinite(array, 4)) {
	this->setRect(rect); // devolve into a simple rect
	return;
	}

	leftRad = SkMaxScalar(leftRad, 0);
	topRad = SkMaxScalar(topRad, 0);
	rightRad = SkMaxScalar(rightRad, 0);
	bottomRad = SkMaxScalar(bottomRad, 0);

	SkScalar scale = SK_Scalar1;
	if (leftRad + rightRad > fRect.width()) {
	scale = fRect.width() / (leftRad + rightRad);
	}
	if (topRad + bottomRad > fRect.height()) {
	scale = SkMinScalar(scale, fRect.height() / (topRad + bottomRad));
	}

	if (scale < SK_Scalar1) {
	leftRad *= scale;
	topRad *= scale;
	rightRad *= scale;
	bottomRad *= scale;
	}

	if (leftRad == rightRad && topRad == bottomRad) {
	if (leftRad >= SkScalarHalf(fRect.width()) && topRad >= SkScalarHalf(fRect.height())) {
	fType = kOval_Type;
	} else if (0 == leftRad \|\| 0 == topRad) {
	// If the left and (by equality check above) right radii are zero then it is a rect.
	// Same goes for top/bottom.
	fType = kRect_Type;
	leftRad = 0;
	topRad = 0;
	rightRad = 0;
	bottomRad = 0;
	} else {
	fType = kSimple_Type;
	}
	} else {
	fType = kNinePatch_Type;
	}

	fRadii[kUpperLeft_Corner].set(leftRad, topRad);
	fRadii[kUpperRight_Corner].set(rightRad, topRad);
	fRadii[kLowerRight_Corner].set(rightRad, bottomRad);
	fRadii[kLowerLeft_Corner].set(leftRad, bottomRad);

	SkASSERT(this->isValid());
	}

	// These parameters intentionally double. Apropos crbug.com/463920, if one of the
	// radii is huge while the other is small, single precision math can completely
	// miss the fact that a scale is required.
	static double compute_min_scale(double rad1, double rad2, double limit, double curMin) {
	if ((rad1 + rad2) > limit) {
	return SkTMin(curMin, limit / (rad1 + rad2));
	}
	return curMin;
	}

	static bool clamp_to_zero(SkVector radii[4]) {
	bool allCornersSquare = true;

	// Clamp negative radii to zero
	for (int i = 0; i < 4; ++i) {
	if (radii[i].fX <= 0 \|\| radii[i].fY <= 0) {
	// In this case we are being a little fast & loose. Since one of
	// the radii is 0 the corner is square. However, the other radii
	// could still be non-zero and play in the global scale factor
	// computation.
	radii[i].fX = 0;
	radii[i].fY = 0;
	} else {
	allCornersSquare = false;
	}
	}

	return allCornersSquare;
	}

	void SkRRect::setRectRadii(const SkRect& rect, const SkVector radii[4]) {
	if (!this->initializeRect(rect)) {
	return;
	}

	if (!SkScalarsAreFinite(&radii[0].fX, 8)) {
	this->setRect(rect); // devolve into a simple rect
	return;
	}

	memcpy(fRadii, radii, sizeof(fRadii));

	if (clamp_to_zero(fRadii)) {
	this->setRect(rect);
	return;
	}

	this->scaleRadii(rect);
	}

	bool SkRRect::initializeRect(const SkRect& rect) {
	// Check this before sorting because sorting can hide nans.
	if (!rect.isFinite()) {
	*this = SkRRect();
	return false;
	}
	fRect = rect.makeSorted();
	if (fRect.isEmpty()) {
	memset(fRadii, 0, sizeof(fRadii));
	fType = kEmpty_Type;
	return false;
	}
	return true;
	}

	// If we can't distinguish one of the radii relative to the other, force it to zero so it
	// doesn't confuse us later. See crbug.com/850350
	//
	static void flush_to_zero(SkScalar& a, SkScalar& b) {
	SkASSERT(a >= 0);
	SkASSERT(b >= 0);
	if (a + b == a) {
	b = 0;
	} else if (a + b == b) {
	a = 0;
	}
	}

	void SkRRect::scaleRadii(const SkRect& rect) {
	// Proportionally scale down all radii to fit. Find the minimum ratio
	// of a side and the radii on that side (for all four sides) and use
	// that to scale down _all_ the radii. This algorithm is from the
	// W3 spec (http://www.w3.org/TR/css3-background/) section 5.5 - Overlapping
	// Curves:
	// "Let f = min(Li/Si), where i is one of { top, right, bottom, left },
	// Si is the sum of the two corresponding radii of the corners on side i,
	// and Ltop = Lbottom = the width of the box,
	// and Lleft = Lright = the height of the box.
	// If f < 1, then all corner radii are reduced by multiplying them by f."
	double scale = 1.0;

	// The sides of the rectangle may be larger than a float.
	double width = (double)fRect.fRight - (double)fRect.fLeft;
	double height = (double)fRect.fBottom - (double)fRect.fTop;
	scale = compute_min_scale(fRadii[0].fX, fRadii[1].fX, width, scale);
	scale = compute_min_scale(fRadii[1].fY, fRadii[2].fY, height, scale);
	scale = compute_min_scale(fRadii[2].fX, fRadii[3].fX, width, scale);
	scale = compute_min_scale(fRadii[3].fY, fRadii[0].fY, height, scale);

	flush_to_zero(fRadii[0].fX, fRadii[1].fX);
	flush_to_zero(fRadii[1].fY, fRadii[2].fY);
	flush_to_zero(fRadii[2].fX, fRadii[3].fX);
	flush_to_zero(fRadii[3].fY, fRadii[0].fY);

	if (scale < 1.0) {
	SkScaleToSides::AdjustRadii(width, scale, &fRadii[0].fX, &fRadii[1].fX);
	SkScaleToSides::AdjustRadii(height, scale, &fRadii[1].fY, &fRadii[2].fY);
	SkScaleToSides::AdjustRadii(width, scale, &fRadii[2].fX, &fRadii[3].fX);
	SkScaleToSides::AdjustRadii(height, scale, &fRadii[3].fY, &fRadii[0].fY);
	}

	// adjust radii may set x or y to zero; set companion to zero as well
	if (clamp_to_zero(fRadii)) {
	this->setRect(rect);
	return;
	}

	// At this point we're either oval, simple, or complex (not empty or rect).
	this->computeType();

	SkASSERT(this->isValid());
	}

	// This method determines if a point known to be inside the RRect's bounds is
	// inside all the corners.
	bool SkRRect::checkCornerContainment(SkScalar x, SkScalar y) const {
	SkPoint canonicalPt; // (x,y) translated to one of the quadrants
	int index;

	if (kOval_Type == this->type()) {
	canonicalPt.set(x - fRect.centerX(), y - fRect.centerY());
	index = kUpperLeft_Corner; // any corner will do in this case
	} else {
	if (x < fRect.fLeft + fRadii[kUpperLeft_Corner].fX &&
	y < fRect.fTop + fRadii[kUpperLeft_Corner].fY) {
	// UL corner
	index = kUpperLeft_Corner;
	canonicalPt.set(x - (fRect.fLeft + fRadii[kUpperLeft_Corner].fX),
	y - (fRect.fTop + fRadii[kUpperLeft_Corner].fY));
	SkASSERT(canonicalPt.fX < 0 && canonicalPt.fY < 0);
	} else if (x < fRect.fLeft + fRadii[kLowerLeft_Corner].fX &&
	y > fRect.fBottom - fRadii[kLowerLeft_Corner].fY) {
	// LL corner
	index = kLowerLeft_Corner;
	canonicalPt.set(x - (fRect.fLeft + fRadii[kLowerLeft_Corner].fX),
	y - (fRect.fBottom - fRadii[kLowerLeft_Corner].fY));
	SkASSERT(canonicalPt.fX < 0 && canonicalPt.fY > 0);
	} else if (x > fRect.fRight - fRadii[kUpperRight_Corner].fX &&
	y < fRect.fTop + fRadii[kUpperRight_Corner].fY) {
	// UR corner
	index = kUpperRight_Corner;
	canonicalPt.set(x - (fRect.fRight - fRadii[kUpperRight_Corner].fX),
	y - (fRect.fTop + fRadii[kUpperRight_Corner].fY));
	SkASSERT(canonicalPt.fX > 0 && canonicalPt.fY < 0);
	} else if (x > fRect.fRight - fRadii[kLowerRight_Corner].fX &&
	y > fRect.fBottom - fRadii[kLowerRight_Corner].fY) {
	// LR corner
	index = kLowerRight_Corner;
	canonicalPt.set(x - (fRect.fRight - fRadii[kLowerRight_Corner].fX),
	y - (fRect.fBottom - fRadii[kLowerRight_Corner].fY));
	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
	// or :
	// b^2x^2 + a^2y^2 <= (ab)^2
	SkScalar dist = SkScalarSquare(canonicalPt.fX) * SkScalarSquare(fRadii[index].fY) +
	SkScalarSquare(canonicalPt.fY) * SkScalarSquare(fRadii[index].fX);
	return dist <= SkScalarSquare(fRadii[index].fX * fRadii[index].fY);
	}

	bool SkRRectPriv::AllCornersCircular(const SkRRect& rr, SkScalar tolerance) {
	return SkScalarNearlyEqual(rr.fRadii[0].fX, rr.fRadii[0].fY, tolerance) &&
	SkScalarNearlyEqual(rr.fRadii[1].fX, rr.fRadii[1].fY, tolerance) &&
	SkScalarNearlyEqual(rr.fRadii[2].fX, rr.fRadii[2].fY, tolerance) &&
	SkScalarNearlyEqual(rr.fRadii[3].fX, rr.fRadii[3].fY, tolerance);
	}

	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;
	}

	// At this point we know all four corners of 'rect' are inside the
	// bounds of of this RR. Check to make sure all the corners are inside
	// all the curves
	return this->checkCornerContainment(rect.fLeft, rect.fTop) &&
	this->checkCornerContainment(rect.fRight, rect.fTop) &&
	this->checkCornerContainment(rect.fRight, rect.fBottom) &&
	this->checkCornerContainment(rect.fLeft, rect.fBottom);
	}

	static bool radii_are_nine_patch(const SkVector radii[4]) {
	return radii[SkRRect::kUpperLeft_Corner].fX == radii[SkRRect::kLowerLeft_Corner].fX &&
	radii[SkRRect::kUpperLeft_Corner].fY == radii[SkRRect::kUpperRight_Corner].fY &&
	radii[SkRRect::kUpperRight_Corner].fX == radii[SkRRect::kLowerRight_Corner].fX &&
	radii[SkRRect::kLowerLeft_Corner].fY == radii[SkRRect::kLowerRight_Corner].fY;
	}

	// There is a simplified version of this method in setRectXY
	void SkRRect::computeType() {
	if (fRect.isEmpty()) {
	SkASSERT(fRect.isSorted());
	for (size_t i = 0; i < SK_ARRAY_COUNT(fRadii); ++i) {
	SkASSERT((fRadii[i] == SkVector{0, 0}));
	}
	fType = kEmpty_Type;
	SkASSERT(this->isValid());
	return;
	}

	bool allRadiiEqual = true; // are all x radii equal and all y radii?
	bool allCornersSquare = 0 == fRadii[0].fX \|\| 0 == fRadii[0].fY;

	for (int i = 1; i < 4; ++i) {
	if (0 != fRadii[i].fX && 0 != fRadii[i].fY) {
	// if either radius is zero the corner is square so both have to
	// be non-zero to have a rounded corner
	allCornersSquare = false;
	}
	if (fRadii[i].fX != fRadii[i-1].fX \|\| fRadii[i].fY != fRadii[i-1].fY) {
	allRadiiEqual = false;
	}
	}

	if (allCornersSquare) {
	fType = kRect_Type;
	SkASSERT(this->isValid());
	return;
	}

	if (allRadiiEqual) {
	if (fRadii[0].fX >= SkScalarHalf(fRect.width()) &&
	fRadii[0].fY >= SkScalarHalf(fRect.height())) {
	fType = kOval_Type;
	} else {
	fType = kSimple_Type;
	}
	SkASSERT(this->isValid());
	return;
	}

	if (radii_are_nine_patch(fRadii)) {
	fType = kNinePatch_Type;
	} else {
	fType = kComplex_Type;
	}
	SkASSERT(this->isValid());
	}

	bool SkRRect::transform(const SkMatrix& matrix, SkRRect* dst) const {
	if (nullptr == dst) {
	return false;
	}

	// Assert that the caller is not trying to do this in place, which
	// would violate const-ness. Do not return false though, so that
	// if they know what they're doing and want to violate it they can.
	SkASSERT(dst != this);

	if (matrix.isIdentity()) {
	dst = this;
	return true;
	}

	if (!matrix.preservesAxisAlignment()) {
	return false;
	}

	SkRect newRect;
	if (!matrix.mapRect(&newRect, fRect)) {
	return false;
	}

	// The matrix may have scaled us to zero (or due to float madness, we now have collapsed
	// some dimension of the rect, so we need to check for that. Note that matrix must be
	// scale and translate and mapRect() produces a sorted rect. So an empty rect indicates
	// loss of precision.
	if (!newRect.isFinite() \|\| newRect.isEmpty()) {
	return false;
	}

	// At this point, this is guaranteed to succeed, so we can modify dst.
	dst->fRect = newRect;

	// Since the only transforms that were allowed are axis aligned, the type
	// remains unchanged.
	dst->fType = fType;

	if (kRect_Type == fType) {
	SkASSERT(dst->isValid());
	return true;
	}
	if (kOval_Type == fType) {
	for (int i = 0; i < 4; ++i) {
	dst->fRadii[i].fX = SkScalarHalf(newRect.width());
	dst->fRadii[i].fY = SkScalarHalf(newRect.height());
	}
	SkASSERT(dst->isValid());
	return true;
	}

	// Now scale each corner
	SkScalar xScale = matrix.getScaleX();
	SkScalar yScale = matrix.getScaleY();

	// There is a rotation of 90 (Clockwise 90) or 270 (Counter clockwise 90).
	// 180 degrees rotations are simply flipX with a flipY and would come under
	// a scale transform.
	if (!matrix.isScaleTranslate()) {
	const bool isClockwise = matrix.getSkewX() < 0;

	// The matrix location for scale changes if there is a rotation.
	xScale = matrix.getSkewY() * (isClockwise ? 1 : -1);
	yScale = matrix.getSkewX() * (isClockwise ? -1 : 1);

	const int dir = isClockwise ? 3 : 1;
	for (int i = 0; i < 4; ++i) {
	const int src = (i + dir) >= 4 ? (i + dir) % 4 : (i + dir);
	// Swap X and Y axis for the radii.
	dst->fRadii[i].fX = fRadii[src].fY;
	dst->fRadii[i].fY = fRadii[src].fX;
	}
	} else {
	for (int i = 0; i < 4; ++i) {
	dst->fRadii[i].fX = fRadii[i].fX;
	dst->fRadii[i].fY = fRadii[i].fY;
	}
	}

	const bool flipX = xScale < 0;
	if (flipX) {
	xScale = -xScale;
	}

	const bool flipY = yScale < 0;
	if (flipY) {
	yScale = -yScale;
	}

	// Scale the radii without respecting the flip.
	for (int i = 0; i < 4; ++i) {
	dst->fRadii[i].fX *= xScale;
	dst->fRadii[i].fY *= yScale;
	}

	// Now swap as necessary.
	using std::swap;
	if (flipX) {
	if (flipY) {
	// Swap with opposite corners
	swap(dst->fRadii[kUpperLeft_Corner], dst->fRadii[kLowerRight_Corner]);
	swap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kLowerLeft_Corner]);
	} else {
	// Only swap in x
	swap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kUpperLeft_Corner]);
	swap(dst->fRadii[kLowerRight_Corner], dst->fRadii[kLowerLeft_Corner]);
	}
	} else if (flipY) {
	// Only swap in y
	swap(dst->fRadii[kUpperLeft_Corner], dst->fRadii[kLowerLeft_Corner]);
	swap(dst->fRadii[kUpperRight_Corner], dst->fRadii[kLowerRight_Corner]);
	}

	if (!AreRectAndRadiiValid(dst->fRect, dst->fRadii)) {
	return false;
	}

	dst->scaleRadii(dst->fRect);
	dst->isValid();

	return true;
	}

	///////////////////////////////////////////////////////////////////////////////

	void SkRRect::inset(SkScalar dx, SkScalar dy, SkRRect* dst) const {
	SkRect r = fRect.makeInset(dx, dy);
	bool degenerate = false;
	if (r.fRight <= r.fLeft) {
	degenerate = true;
	r.fLeft = r.fRight = SkScalarAve(r.fLeft, r.fRight);
	}
	if (r.fBottom <= r.fTop) {
	degenerate = true;
	r.fTop = r.fBottom = SkScalarAve(r.fTop, r.fBottom);
	}
	if (degenerate) {
	dst->fRect = r;
	memset(dst->fRadii, 0, sizeof(dst->fRadii));
	dst->fType = kEmpty_Type;
	return;
	}
	if (!r.isFinite()) {
	*dst = SkRRect();
	return;
	}

	SkVector radii[4];
	memcpy(radii, fRadii, sizeof(radii));
	for (int i = 0; i < 4; ++i) {
	if (radii[i].fX) {
	radii[i].fX -= dx;
	}
	if (radii[i].fY) {
	radii[i].fY -= dy;
	}
	}
	dst->setRectRadii(r, radii);
	}

	///////////////////////////////////////////////////////////////////////////////

	size_t SkRRect::writeToMemory(void* buffer) const {
	// Serialize only the rect and corners, but not the derived type tag.
	memcpy(buffer, this, kSizeInMemory);
	return kSizeInMemory;
	}

	void SkRRectPriv::WriteToBuffer(const SkRRect& rr, SkWBuffer* buffer) {
	// Serialize only the rect and corners, but not the derived type tag.
	buffer->write(&rr, SkRRect::kSizeInMemory);
	}

	size_t SkRRect::readFromMemory(const void* buffer, size_t length) {
	if (length < kSizeInMemory) {
	return 0;
	}

	SkRRect raw;
	memcpy(&raw, buffer, kSizeInMemory);
	this->setRectRadii(raw.fRect, raw.fRadii);
	return kSizeInMemory;
	}

	bool SkRRectPriv::ReadFromBuffer(SkRBuffer* buffer, SkRRect* rr) {
	if (buffer->available() < SkRRect::kSizeInMemory) {
	return false;
	}
	SkRRect storage;
	return buffer->read(&storage, SkRRect::kSizeInMemory) &&
	(rr->readFromMemory(&storage, SkRRect::kSizeInMemory) == SkRRect::kSizeInMemory);
	}

	#include "SkString.h"
	#include "SkStringUtils.h"

	void SkRRect::dump(bool asHex) const {
	SkScalarAsStringType asType = asHex ? kHex_SkScalarAsStringType : kDec_SkScalarAsStringType;

	fRect.dump(asHex);
	SkString line("const SkPoint corners[] = {\n");
	for (int i = 0; i < 4; ++i) {
	SkString strX, strY;
	SkAppendScalar(&strX, fRadii[i].x(), asType);
	SkAppendScalar(&strY, fRadii[i].y(), asType);
	line.appendf(" { %s, %s },", strX.c_str(), strY.c_str());
	if (asHex) {
	line.appendf(" /* %f %f */", fRadii[i].x(), fRadii[i].y());
	}
	line.append("\n");
	}
	line.append("};");
	SkDebugf("%s\n", line.c_str());
	}

	///////////////////////////////////////////////////////////////////////////////

	/**
	* We need all combinations of predicates to be true to have a "safe" radius value.
	*/
	static bool are_radius_check_predicates_valid(SkScalar rad, SkScalar min, SkScalar max) {
	return (min <= max) && (rad <= max - min) && (min + rad <= max) && (max - rad >= min) &&
	rad >= 0;
	}

	bool SkRRect::isValid() const {
	if (!AreRectAndRadiiValid(fRect, fRadii)) {
	return false;
	}

	bool allRadiiZero = (0 == fRadii[0].fX && 0 == fRadii[0].fY);
	bool allCornersSquare = (0 == fRadii[0].fX \|\| 0 == fRadii[0].fY);
	bool allRadiiSame = true;

	for (int i = 1; i < 4; ++i) {
	if (0 != fRadii[i].fX \|\| 0 != fRadii[i].fY) {
	allRadiiZero = false;
	}

	if (fRadii[i].fX != fRadii[i-1].fX \|\| fRadii[i].fY != fRadii[i-1].fY) {
	allRadiiSame = false;
	}

	if (0 != fRadii[i].fX && 0 != fRadii[i].fY) {
	allCornersSquare = false;
	}
	}
	bool patchesOfNine = radii_are_nine_patch(fRadii);

	if (fType < 0 \|\| fType > kLastType) {
	return false;
	}

	switch (fType) {
	case kEmpty_Type:
	if (!fRect.isEmpty() \|\| !allRadiiZero \|\| !allRadiiSame \|\| !allCornersSquare) {
	return false;
	}
	break;
	case kRect_Type:
	if (fRect.isEmpty() \|\| !allRadiiZero \|\| !allRadiiSame \|\| !allCornersSquare) {
	return false;
	}
	break;
	case kOval_Type:
	if (fRect.isEmpty() \|\| allRadiiZero \|\| !allRadiiSame \|\| allCornersSquare) {
	return false;
	}

	for (int i = 0; i < 4; ++i) {
	if (!SkScalarNearlyEqual(fRadii[i].fX, SkScalarHalf(fRect.width())) \|\|
	!SkScalarNearlyEqual(fRadii[i].fY, SkScalarHalf(fRect.height()))) {
	return false;
	}
	}
	break;
	case kSimple_Type:
	if (fRect.isEmpty() \|\| allRadiiZero \|\| !allRadiiSame \|\| allCornersSquare) {
	return false;
	}
	break;
	case kNinePatch_Type:
	if (fRect.isEmpty() \|\| allRadiiZero \|\| allRadiiSame \|\| allCornersSquare \|\|
	!patchesOfNine) {
	return false;
	}
	break;
	case kComplex_Type:
	if (fRect.isEmpty() \|\| allRadiiZero \|\| allRadiiSame \|\| allCornersSquare \|\|
	patchesOfNine) {
	return false;
	}
	break;
	}

	return true;
	}

	bool SkRRect::AreRectAndRadiiValid(const SkRect& rect, const SkVector radii[4]) {
	if (!rect.isFinite() \|\| !rect.isSorted()) {
	return false;
	}
	for (int i = 0; i < 4; ++i) {
	if (!are_radius_check_predicates_valid(radii[i].fX, rect.fLeft, rect.fRight) \|\|
	!are_radius_check_predicates_valid(radii[i].fY, rect.fTop, rect.fBottom)) {
	return false;
	}
	}
	return true;
	}
	///////////////////////////////////////////////////////////////////////////////