Home | History | Annotate | Download | only in graphics 
      1 /*
      2  * Copyright (C) 2004, 2006, 2007 Apple Inc.  All rights reserved.
      3  * Copyright (C) 2005 Nokia.  All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  *
     14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  */
     26 
     27 #include "config.h"
     28 #include "core/platform/graphics/FloatPoint.h"
     29 
     30 #include <math.h>
     31 #include <limits>
     32 #include "core/platform/FloatConversion.h"
     33 #include "core/platform/graphics/IntPoint.h"
     34 #include "core/platform/graphics/LayoutPoint.h"
     35 #include "core/platform/graphics/LayoutSize.h"
     36 #include "core/platform/graphics/skia/SkiaUtils.h"
     37 #include "core/platform/graphics/transforms/AffineTransform.h"
     38 #include "core/platform/graphics/transforms/TransformationMatrix.h"
     39 #include "third_party/skia/include/core/SkPoint.h"
     40 
     41 namespace WebCore {
     42 
     43 FloatPoint::FloatPoint(const IntPoint& p) : m_x(p.x()), m_y(p.y())
     44 {
     45 }
     46 
     47 FloatPoint::FloatPoint(const LayoutPoint& p) : m_x(p.x()), m_y(p.y())
     48 {
     49 }
     50 
     51 void FloatPoint::normalize()
     52 {
     53     float tempLength = length();
     54 
     55     if (tempLength) {
     56         m_x /= tempLength;
     57         m_y /= tempLength;
     58     }
     59 }
     60 
     61 float FloatPoint::slopeAngleRadians() const
     62 {
     63     return atan2f(m_y, m_x);
     64 }
     65 
     66 float FloatPoint::length() const
     67 {
     68     return sqrtf(lengthSquared());
     69 }
     70 
     71 void FloatPoint::move(const LayoutSize& size)
     72 {
     73     m_x += size.width();
     74     m_y += size.height();
     75 }
     76 
     77 void FloatPoint::moveBy(const LayoutPoint& point)
     78 {
     79     m_x += point.x();
     80     m_y += point.y();
     81 }
     82 
     83 FloatPoint::operator SkPoint() const
     84 {
     85     SkPoint p = { WebCoreFloatToSkScalar(m_x), WebCoreFloatToSkScalar(m_y) };
     86     return p;
     87 }
     88 
     89 FloatPoint FloatPoint::matrixTransform(const AffineTransform& transform) const
     90 {
     91     double newX, newY;
     92     transform.map(static_cast<double>(m_x), static_cast<double>(m_y), newX, newY);
     93     return narrowPrecision(newX, newY);
     94 }
     95 
     96 FloatPoint FloatPoint::matrixTransform(const TransformationMatrix& transform) const
     97 {
     98     double newX, newY;
     99     transform.map(static_cast<double>(m_x), static_cast<double>(m_y), newX, newY);
    100     return narrowPrecision(newX, newY);
    101 }
    102 
    103 FloatPoint FloatPoint::narrowPrecision(double x, double y)
    104 {
    105     return FloatPoint(narrowPrecisionToFloat(x), narrowPrecisionToFloat(y));
    106 }
    107 
    108 float findSlope(const FloatPoint& p1, const FloatPoint& p2, float& c)
    109 {
    110     if (p2.x() == p1.x())
    111         return std::numeric_limits<float>::infinity();
    112 
    113     // y = mx + c
    114     float slope = (p2.y() - p1.y()) / (p2.x() - p1.x());
    115     c = p1.y() - slope * p1.x();
    116     return slope;
    117 }
    118 
    119 bool findIntersection(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& d1, const FloatPoint& d2, FloatPoint& intersection)
    120 {
    121     float pOffset = 0;
    122     float pSlope = findSlope(p1, p2, pOffset);
    123 
    124     float dOffset = 0;
    125     float dSlope = findSlope(d1, d2, dOffset);
    126 
    127     if (dSlope == pSlope)
    128         return false;
    129 
    130     if (pSlope == std::numeric_limits<float>::infinity()) {
    131         intersection.setX(p1.x());
    132         intersection.setY(dSlope * intersection.x() + dOffset);
    133         return true;
    134     }
    135     if (dSlope == std::numeric_limits<float>::infinity()) {
    136         intersection.setX(d1.x());
    137         intersection.setY(pSlope * intersection.x() + pOffset);
    138         return true;
    139     }
    140 
    141     // Find x at intersection, where ys overlap; x = (c' - c) / (m - m')
    142     intersection.setX((dOffset - pOffset) / (pSlope - dSlope));
    143     intersection.setY(pSlope * intersection.x() + pOffset);
    144     return true;
    145 }
    146 
    147 }
    148