SkPoint.cpp revision 910f694aefb0b671dd8522a9afe9b6be645701c1 
1
2/*
3 * Copyright 2008 The Android Open Source Project
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10#include "SkPoint.h"
11
12void SkIPoint::rotateCW(SkIPoint* dst) const {
13    SkASSERT(dst);
14
15    // use a tmp in case this == dst
16    int32_t tmp = fX;
17    dst->fX = -fY;
18    dst->fY = tmp;
19}
20
21void SkIPoint::rotateCCW(SkIPoint* dst) const {
22    SkASSERT(dst);
23
24    // use a tmp in case this == dst
25    int32_t tmp = fX;
26    dst->fX = fY;
27    dst->fY = -tmp;
28}
29
30///////////////////////////////////////////////////////////////////////////////
31
32void SkPoint::setIRectFan(int l, int t, int r, int b, size_t stride) {
33    SkASSERT(stride >= sizeof(SkPoint));
34
35    ((SkPoint*)((intptr_t)this + 0 * stride))->set(SkIntToScalar(l),
36                                                   SkIntToScalar(t));
37    ((SkPoint*)((intptr_t)this + 1 * stride))->set(SkIntToScalar(l),
38                                                   SkIntToScalar(b));
39    ((SkPoint*)((intptr_t)this + 2 * stride))->set(SkIntToScalar(r),
40                                                   SkIntToScalar(b));
41    ((SkPoint*)((intptr_t)this + 3 * stride))->set(SkIntToScalar(r),
42                                                   SkIntToScalar(t));
43}
44
45void SkPoint::setRectFan(SkScalar l, SkScalar t, SkScalar r, SkScalar b,
46                         size_t stride) {
47    SkASSERT(stride >= sizeof(SkPoint));
48
49    ((SkPoint*)((intptr_t)this + 0 * stride))->set(l, t);
50    ((SkPoint*)((intptr_t)this + 1 * stride))->set(l, b);
51    ((SkPoint*)((intptr_t)this + 2 * stride))->set(r, b);
52    ((SkPoint*)((intptr_t)this + 3 * stride))->set(r, t);
53}
54
55void SkPoint::rotateCW(SkPoint* dst) const {
56    SkASSERT(dst);
57
58    // use a tmp in case this == dst
59    SkScalar tmp = fX;
60    dst->fX = -fY;
61    dst->fY = tmp;
62}
63
64void SkPoint::rotateCCW(SkPoint* dst) const {
65    SkASSERT(dst);
66
67    // use a tmp in case this == dst
68    SkScalar tmp = fX;
69    dst->fX = fY;
70    dst->fY = -tmp;
71}
72
73void SkPoint::scale(SkScalar scale, SkPoint* dst) const {
74    SkASSERT(dst);
75    dst->set(SkScalarMul(fX, scale), SkScalarMul(fY, scale));
76}
77
78bool SkPoint::normalize() {
79    return this->setLength(fX, fY, SK_Scalar1);
80}
81
82bool SkPoint::setNormalize(SkScalar x, SkScalar y) {
83    return this->setLength(x, y, SK_Scalar1);
84}
85
86bool SkPoint::setLength(SkScalar length) {
87    return this->setLength(fX, fY, length);
88}
89
90// Returns the square of the Euclidian distance to (dx,dy).
91static inline float getLengthSquared(float dx, float dy) {
92    return dx * dx + dy * dy;
93}
94
95// Calculates the square of the Euclidian distance to (dx,dy) and stores it in
96// *lengthSquared.  Returns true if the distance is judged to be "nearly zero".
97//
98// This logic is encapsulated in a helper method to make it explicit that we
99// always perform this check in the same manner, to avoid inconsistencies
100// (see http://code.google.com/p/skia/issues/detail?id=560 ).
101static inline bool isLengthNearlyZero(float dx, float dy,
102                                      float *lengthSquared) {
103    *lengthSquared = getLengthSquared(dx, dy);
104    return *lengthSquared <= (SK_ScalarNearlyZero * SK_ScalarNearlyZero);
105}
106
107SkScalar SkPoint::Normalize(SkPoint* pt) {
108    float x = pt->fX;
109    float y = pt->fY;
110    float mag2;
111    if (isLengthNearlyZero(x, y, &mag2)) {
112        return 0;
113    }
114
115    float mag, scale;
116    if (SkScalarIsFinite(mag2)) {
117        mag = sk_float_sqrt(mag2);
118        scale = 1 / mag;
119    } else {
120        // our mag2 step overflowed to infinity, so use doubles instead.
121        // much slower, but needed when x or y are very large, other wise we
122        // divide by inf. and return (0,0) vector.
123        double xx = x;
124        double yy = y;
125        double magmag = sqrt(xx * xx + yy * yy);
126        mag = (float)magmag;
127        // we perform the divide with the double magmag, to stay exactly the
128        // same as setLength. It would be faster to perform the divide with
129        // mag, but it is possible that mag has overflowed to inf. but still
130        // have a non-zero value for scale (thanks to denormalized numbers).
131        scale = (float)(1 / magmag);
132    }
133    pt->set(x * scale, y * scale);
134    return mag;
135}
136
137SkScalar SkPoint::Length(SkScalar dx, SkScalar dy) {
138    float mag2 = dx * dx + dy * dy;
139    if (SkScalarIsFinite(mag2)) {
140        return sk_float_sqrt(mag2);
141    } else {
142        double xx = dx;
143        double yy = dy;
144        return (float)sqrt(xx * xx + yy * yy);
145    }
146}
147
148/*
149 *  We have to worry about 2 tricky conditions:
150 *  1. underflow of mag2 (compared against nearlyzero^2)
151 *  2. overflow of mag2 (compared w/ isfinite)
152 *
153 *  If we underflow, we return false. If we overflow, we compute again using
154 *  doubles, which is much slower (3x in a desktop test) but will not overflow.
155 */
156bool SkPoint::setLength(float x, float y, float length) {
157    float mag2;
158    if (isLengthNearlyZero(x, y, &mag2)) {
159        return false;
160    }
161
162    float scale;
163    if (SkScalarIsFinite(mag2)) {
164        scale = length / sk_float_sqrt(mag2);
165    } else {
166        // our mag2 step overflowed to infinity, so use doubles instead.
167        // much slower, but needed when x or y are very large, other wise we
168        // divide by inf. and return (0,0) vector.
169        double xx = x;
170        double yy = y;
171        scale = (float)(length / sqrt(xx * xx + yy * yy));
172    }
173    fX = x * scale;
174    fY = y * scale;
175    return true;
176}
177
178bool SkPoint::setLengthFast(float length) {
179    return this->setLengthFast(fX, fY, length);
180}
181
182bool SkPoint::setLengthFast(float x, float y, float length) {
183    float mag2;
184    if (isLengthNearlyZero(x, y, &mag2)) {
185        return false;
186    }
187
188    float scale;
189    if (SkScalarIsFinite(mag2)) {
190        scale = length * sk_float_rsqrt(mag2);  // <--- this is the difference
191    } else {
192        // our mag2 step overflowed to infinity, so use doubles instead.
193        // much slower, but needed when x or y are very large, other wise we
194        // divide by inf. and return (0,0) vector.
195        double xx = x;
196        double yy = y;
197        scale = (float)(length / sqrt(xx * xx + yy * yy));
198    }
199    fX = x * scale;
200    fY = y * scale;
201    return true;
202}
203
204
205///////////////////////////////////////////////////////////////////////////////
206
207SkScalar SkPoint::distanceToLineBetweenSqd(const SkPoint& a,
208                                           const SkPoint& b,
209                                           Side* side) const {
210
211    SkVector u = b - a;
212    SkVector v = *this - a;
213
214    SkScalar uLengthSqd = u.lengthSqd();
215    SkScalar det = u.cross(v);
216    if (NULL != side) {
217        SkASSERT(-1 == SkPoint::kLeft_Side &&
218                  0 == SkPoint::kOn_Side &&
219                  1 == kRight_Side);
220        *side = (Side) SkScalarSignAsInt(det);
221    }
222    return SkScalarMulDiv(det, det, uLengthSqd);
223}
224
225SkScalar SkPoint::distanceToLineSegmentBetweenSqd(const SkPoint& a,
226                                                  const SkPoint& b) const {
227    // See comments to distanceToLineBetweenSqd. If the projection of c onto
228    // u is between a and b then this returns the same result as that
229    // function. Otherwise, it returns the distance to the closer of a and
230    // b. Let the projection of v onto u be v'.  There are three cases:
231    //    1. v' points opposite to u. c is not between a and b and is closer
232    //       to a than b.
233    //    2. v' points along u and has magnitude less than y. c is between
234    //       a and b and the distance to the segment is the same as distance
235    //       to the line ab.
236    //    3. v' points along u and has greater magnitude than u. c is not
237    //       not between a and b and is closer to b than a.
238    // v' = (u dot v) * u / |u|. So if (u dot v)/|u| is less than zero we're
239    // in case 1. If (u dot v)/|u| is > |u| we are in case 3. Otherwise
240    // we're in case 2. We actually compare (u dot v) to 0 and |u|^2 to
241    // avoid a sqrt to compute |u|.
242
243    SkVector u = b - a;
244    SkVector v = *this - a;
245
246    SkScalar uLengthSqd = u.lengthSqd();
247    SkScalar uDotV = SkPoint::DotProduct(u, v);
248
249    if (uDotV <= 0) {
250        return v.lengthSqd();
251    } else if (uDotV > uLengthSqd) {
252        return b.distanceToSqd(*this);
253    } else {
254        SkScalar det = u.cross(v);
255        return SkScalarMulDiv(det, det, uLengthSqd);
256    }
257}
258