// This function is used to scale an image and extract a scaled fragment. // // ALGORITHM // // Because the scaled image size has to be integers, we approximate the real // scale with the following formula (only X direction is shown): // // scaledImageWidth = round(scaleX * imageRect.width()) // approximateScaleX = scaledImageWidth / imageRect.width() // // With this method we maintain a constant scale factor among fragments in // the scaled image. This allows fragments to stitch together to form the // full scaled image. The downside is there will be a small difference // between |scaleX| and |approximateScaleX|. // // A scaled image fragment is identified by: // // - Scaled image size // - Scaled image fragment rectangle (IntRect) // // Scaled image size has been determined and the next step is to compute the // rectangle for the scaled image fragment which needs to be an IntRect. // // scaledSrcRect = srcRect * (approximateScaleX, approximateScaleY) // enclosingScaledSrcRect = enclosingIntRect(scaledSrcRect) // // Finally we extract the scaled image fragment using // (scaledImageSize, enclosingScaledSrcRect). // SkBitmap NativeImageSkia::extractScaledImageFragment(const SkRect& srcRect, float scaleX, float scaleY, SkRect* scaledSrcRect) const { SkISize imageSize = SkISize::Make(bitmap().width(), bitmap().height()); SkISize scaledImageSize = SkISize::Make(clampToInteger(roundf(imageSize.width() * scaleX)), clampToInteger(roundf(imageSize.height() * scaleY))); SkRect imageRect = SkRect::MakeWH(imageSize.width(), imageSize.height()); SkRect scaledImageRect = SkRect::MakeWH(scaledImageSize.width(), scaledImageSize.height()); SkMatrix scaleTransform; scaleTransform.setRectToRect(imageRect, scaledImageRect, SkMatrix::kFill_ScaleToFit); scaleTransform.mapRect(scaledSrcRect, srcRect); bool ok = scaledSrcRect->intersect(scaledImageRect); ASSERT_UNUSED(ok, ok); SkIRect enclosingScaledSrcRect = enclosingIntRect(*scaledSrcRect); // |enclosingScaledSrcRect| can be larger than |scaledImageSize| because // of float inaccuracy so clip to get inside. ok = enclosingScaledSrcRect.intersect(SkIRect::MakeSize(scaledImageSize)); ASSERT_UNUSED(ok, ok); // scaledSrcRect is relative to the pixel snapped fragment we're extracting. scaledSrcRect->offset(-enclosingScaledSrcRect.x(), -enclosingScaledSrcRect.y()); return resizedBitmap(scaledImageSize, enclosingScaledSrcRect); }
PassOwnPtr<RasterShapeIntervals> RasterShapeIntervals::computeShapeMarginIntervals(unsigned shapeMargin) const { OwnPtr<RasterShapeIntervals> result = adoptPtr(new RasterShapeIntervals(size(), shapeMargin)); MarginIntervalGenerator marginIntervalGenerator(shapeMargin); int minY = bounds().y(); int maxY = bounds().maxY(); for (int y = minY; y < maxY; ++y) { const IntShapeInterval& intervalAtY = limitIntervalAt(y); if (intervalAtY.isEmpty()) continue; marginIntervalGenerator.set(y, intervalAtY); int marginY0 = y - clampToInteger(shapeMargin); int marginY1 = y + clampToInteger(shapeMargin); for (int marginY = y - 1; marginY >= marginY0; --marginY) { if (marginY > minY && limitIntervalAt(marginY).contains(intervalAtY)) break; result->uniteMarginInterval(marginY, marginIntervalGenerator.intervalAt(marginY)); } result->uniteMarginInterval(y, marginIntervalGenerator.intervalAt(y)); for (int marginY = y + 1; marginY <= marginY1; ++marginY) { if (marginY < maxY && limitIntervalAt(marginY).contains(intervalAtY)) break; result->uniteMarginInterval(marginY, marginIntervalGenerator.intervalAt(marginY)); } } return result.release(); }
IntRect enclosingIntRect(const FractionalLayoutRect& rect) { float x = floorf(rect.x().toFloat()); float y = floorf(rect.y().toFloat()); float width = ceilf(rect.maxX().toFloat()) - x; float height = ceilf(rect.maxY().toFloat()) - y; return IntRect(clampToInteger(x), clampToInteger(y), clampToInteger(width), clampToInteger(height)); }
IntRect enclosingIntRect(const FloatRect& rect) { float left = floorf(rect.x()); float top = floorf(rect.y()); float width = ceilf(rect.maxX()) - left; float height = ceilf(rect.maxY()) - top; return IntRect(clampToInteger(left), clampToInteger(top), clampToInteger(width), clampToInteger(height)); }
JSValue JSWebSocket::close(ExecState* exec) { // FIXME: We should implement [Clamp] for IDL binding code generator, and // remove this custom method. WebSocket* webSocket = static_cast<WebSocket*>(impl()); size_t argumentCount = exec->argumentCount(); int code = WebSocketChannel::CloseEventCodeNotSpecified; String reason = ""; if (argumentCount >= 1) { JSValue v = exec->argument(0); double x = v.toNumber(exec); double maxValue = static_cast<double>(std::numeric_limits<uint16_t>::max()); double minValue = static_cast<double>(std::numeric_limits<uint16_t>::min()); if (isnan(x)) x = 0.0; else x = clampTo(x, minValue, maxValue); code = clampToInteger(x); if (argumentCount >= 2) { reason = ustringToString(exec->argument(1).toString(exec)->value(exec)); if (exec->hadException()) { setDOMException(exec, SYNTAX_ERR); return jsUndefined(); } } } ExceptionCode ec = 0; webSocket->close(code, reason, ec); setDOMException(exec, ec); return jsUndefined(); }
v8::Handle<v8::Value> V8WebSocket::closeCallback(const v8::Arguments& args) { // FIXME: We should implement [Clamp] for IDL binding code generator, and // remove this custom method. WebSocket* webSocket = toNative(args.Holder()); int argumentCount = args.Length(); int code = WebSocketChannel::CloseEventCodeNotSpecified; String reason = ""; if (argumentCount >= 1) { double x = args[0]->NumberValue(); double maxValue = static_cast<double>(std::numeric_limits<uint16_t>::max()); double minValue = static_cast<double>(std::numeric_limits<uint16_t>::min()); if (isnan(x)) x = 0.0; else x = clampTo(x, minValue, maxValue); code = clampToInteger(x); if (argumentCount >= 2) { v8::TryCatch tryCatch; v8::Handle<v8::String> reasonValue = args[1]->ToString(); if (tryCatch.HasCaught()) return throwError(tryCatch.Exception()); reason = toWebCoreString(reasonValue); } } ExceptionCode ec = 0; webSocket->close(code, reason, ec); if (ec) return throwError(ec); return v8::Undefined(); }
// This function is used to scale an image and extract a scaled fragment. // // ALGORITHM // // Because the scaled image size has to be integers, we approximate the real // scale with the following formula (only X direction is shown): // // scaledImageWidth = round(scaleX * imageRect.width()) // approximateScaleX = scaledImageWidth / imageRect.width() // // With this method we maintain a constant scale factor among fragments in // the scaled image. This allows fragments to stitch together to form the // full scaled image. The downside is there will be a small difference // between |scaleX| and |approximateScaleX|. // // A scaled image fragment is identified by: // // - Scaled image size // - Scaled image fragment rectangle (IntRect) // // Scaled image size has been determined and the next step is to compute the // rectangle for the scaled image fragment which needs to be an IntRect. // // scaledSrcRect = srcRect * (approximateScaleX, approximateScaleY) // enclosingScaledSrcRect = enclosingIntRect(scaledSrcRect) // // Finally we extract the scaled image fragment using // (scaledImageSize, enclosingScaledSrcRect). // static SkBitmap extractScaledImageFragment(const NativeImageSkia& bitmap, const SkRect& srcRect, float scaleX, float scaleY, SkRect* scaledSrcRect, SkIRect* enclosingScaledSrcRect) { SkISize imageSize = SkISize::Make(bitmap.bitmap().width(), bitmap.bitmap().height()); SkISize scaledImageSize = SkISize::Make(clampToInteger(roundf(imageSize.width() * scaleX)), clampToInteger(roundf(imageSize.height() * scaleY))); SkRect imageRect = SkRect::MakeWH(imageSize.width(), imageSize.height()); SkRect scaledImageRect = SkRect::MakeWH(scaledImageSize.width(), scaledImageSize.height()); SkMatrix scaleTransform; scaleTransform.setRectToRect(imageRect, scaledImageRect, SkMatrix::kFill_ScaleToFit); scaleTransform.mapRect(scaledSrcRect, srcRect); scaledSrcRect->intersect(scaledImageRect); *enclosingScaledSrcRect = enclosingIntRect(*scaledSrcRect); // |enclosingScaledSrcRect| can be larger than |scaledImageSize| because // of float inaccuracy so clip to get inside. enclosingScaledSrcRect->intersect(SkIRect::MakeSize(scaledImageSize)); return bitmap.resizedBitmap(scaledImageSize, *enclosingScaledSrcRect); }
IntRect::IntRect(const FloatRect& r) : m_location(clampToInteger(r.x()), clampToInteger(r.y())) , m_size(clampToInteger(r.width()), clampToInteger(r.height())) { }
IntSize::IntSize(const D2D1_SIZE_F& s) : m_width(clampToInteger(s.width)) , m_height(clampToInteger(s.height)) { }
IntPoint::IntPoint(const FloatPoint& p) : m_x(clampToInteger(p.x())) , m_y(clampToInteger(p.y())) { }
IntSize::IntSize(const FloatSize& s) : m_width(clampToInteger(s.width())) , m_height(clampToInteger(s.height())) { }