From 6302288dec6111120749754ba8ec2d249b63404b Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Tue, 25 Apr 2017 10:29:58 -0700 Subject: Rename core/fxcrt/fx_basic_coords.cpp to fx_coordinates.cpp Its contents are delcared in fx_coordinates.h Remove unused GetIntersection(). Move FXSYS_round to fx_system.cpp. Change-Id: I70749581d1321dd919e35fa2daab9591098f68e9 Reviewed-on: https://pdfium-review.googlesource.com/4479 Reviewed-by: dsinclair Commit-Queue: Tom Sepez --- core/fxcrt/fx_coordinates.cpp | 385 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 385 insertions(+) create mode 100644 core/fxcrt/fx_coordinates.cpp (limited to 'core/fxcrt/fx_coordinates.cpp') diff --git a/core/fxcrt/fx_coordinates.cpp b/core/fxcrt/fx_coordinates.cpp new file mode 100644 index 0000000000..ca40a42227 --- /dev/null +++ b/core/fxcrt/fx_coordinates.cpp @@ -0,0 +1,385 @@ +// Copyright 2014 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#include "core/fxcrt/fx_coordinates.h" + +#include + +#include "core/fxcrt/fx_extension.h" + +namespace { + +void MatchFloatRange(float f1, float f2, int* i1, int* i2) { + int length = static_cast(ceil(f2 - f1)); + int i1_1 = static_cast(floor(f1)); + int i1_2 = static_cast(ceil(f1)); + float error1 = f1 - i1_1 + (float)fabs(f2 - i1_1 - length); + float error2 = i1_2 - f1 + (float)fabs(f2 - i1_2 - length); + + *i1 = (error1 > error2) ? i1_2 : i1_1; + *i2 = *i1 + length; +} + +} // namespace + +void FX_RECT::Normalize() { + if (left > right) { + int temp = left; + left = right; + right = temp; + } + if (top > bottom) { + int temp = top; + top = bottom; + bottom = temp; + } +} + +void FX_RECT::Intersect(const FX_RECT& src) { + FX_RECT src_n = src; + src_n.Normalize(); + Normalize(); + left = left > src_n.left ? left : src_n.left; + top = top > src_n.top ? top : src_n.top; + right = right < src_n.right ? right : src_n.right; + bottom = bottom < src_n.bottom ? bottom : src_n.bottom; + if (left > right || top > bottom) { + left = top = right = bottom = 0; + } +} + +CFX_FloatRect::CFX_FloatRect(const FX_RECT& rect) { + left = (float)(rect.left); + right = (float)(rect.right); + bottom = (float)(rect.top); + top = (float)(rect.bottom); +} +void CFX_FloatRect::Normalize() { + float temp; + if (left > right) { + temp = left; + left = right; + right = temp; + } + if (bottom > top) { + temp = top; + top = bottom; + bottom = temp; + } +} +void CFX_FloatRect::Intersect(const CFX_FloatRect& other_rect) { + Normalize(); + CFX_FloatRect other = other_rect; + other.Normalize(); + left = left > other.left ? left : other.left; + right = right < other.right ? right : other.right; + bottom = bottom > other.bottom ? bottom : other.bottom; + top = top < other.top ? top : other.top; + if (left > right || bottom > top) { + left = right = bottom = top = 0; + } +} +void CFX_FloatRect::Union(const CFX_FloatRect& other_rect) { + Normalize(); + CFX_FloatRect other = other_rect; + other.Normalize(); + left = left < other.left ? left : other.left; + right = right > other.right ? right : other.right; + bottom = bottom < other.bottom ? bottom : other.bottom; + top = top > other.top ? top : other.top; +} + +int CFX_FloatRect::Substract4(CFX_FloatRect& s, CFX_FloatRect* pRects) { + Normalize(); + s.Normalize(); + int nRects = 0; + CFX_FloatRect rects[4]; + if (left < s.left) { + rects[nRects].left = left; + rects[nRects].right = s.left; + rects[nRects].bottom = bottom; + rects[nRects].top = top; + nRects++; + } + if (s.left < right && s.top < top) { + rects[nRects].left = s.left; + rects[nRects].right = right; + rects[nRects].bottom = s.top; + rects[nRects].top = top; + nRects++; + } + if (s.top > bottom && s.right < right) { + rects[nRects].left = s.right; + rects[nRects].right = right; + rects[nRects].bottom = bottom; + rects[nRects].top = s.top; + nRects++; + } + if (s.bottom > bottom) { + rects[nRects].left = s.left; + rects[nRects].right = s.right; + rects[nRects].bottom = bottom; + rects[nRects].top = s.bottom; + nRects++; + } + if (nRects == 0) { + return 0; + } + for (int i = 0; i < nRects; i++) { + pRects[i] = rects[i]; + pRects[i].Intersect(*this); + } + return nRects; +} + +FX_RECT CFX_FloatRect::GetOuterRect() const { + CFX_FloatRect rect1 = *this; + FX_RECT rect; + rect.left = (int)floor(rect1.left); + rect.right = (int)ceil(rect1.right); + rect.top = (int)floor(rect1.bottom); + rect.bottom = (int)ceil(rect1.top); + rect.Normalize(); + return rect; +} + +FX_RECT CFX_FloatRect::GetInnerRect() const { + CFX_FloatRect rect1 = *this; + FX_RECT rect; + rect.left = (int)ceil(rect1.left); + rect.right = (int)floor(rect1.right); + rect.top = (int)ceil(rect1.bottom); + rect.bottom = (int)floor(rect1.top); + rect.Normalize(); + return rect; +} + +FX_RECT CFX_FloatRect::GetClosestRect() const { + CFX_FloatRect rect1 = *this; + FX_RECT rect; + MatchFloatRange(rect1.left, rect1.right, &rect.left, &rect.right); + MatchFloatRange(rect1.bottom, rect1.top, &rect.top, &rect.bottom); + rect.Normalize(); + return rect; +} + +bool CFX_FloatRect::Contains(const CFX_PointF& point) const { + CFX_FloatRect n1(*this); + n1.Normalize(); + return point.x <= n1.right && point.x >= n1.left && point.y <= n1.top && + point.y >= n1.bottom; +} + +bool CFX_FloatRect::Contains(const CFX_FloatRect& other_rect) const { + CFX_FloatRect n1(*this); + CFX_FloatRect n2(other_rect); + n1.Normalize(); + n2.Normalize(); + return n2.left >= n1.left && n2.right <= n1.right && n2.bottom >= n1.bottom && + n2.top <= n1.top; +} + +void CFX_FloatRect::UpdateRect(float x, float y) { + left = std::min(left, x); + right = std::max(right, x); + bottom = std::min(bottom, y); + top = std::max(top, y); +} + +CFX_FloatRect CFX_FloatRect::GetBBox(const CFX_PointF* pPoints, int nPoints) { + if (nPoints == 0) + return CFX_FloatRect(); + + float min_x = pPoints->x; + float max_x = pPoints->x; + float min_y = pPoints->y; + float max_y = pPoints->y; + for (int i = 1; i < nPoints; i++) { + min_x = std::min(min_x, pPoints[i].x); + max_x = std::max(max_x, pPoints[i].x); + min_y = std::min(min_y, pPoints[i].y); + max_y = std::max(max_y, pPoints[i].y); + } + return CFX_FloatRect(min_x, min_y, max_x, max_y); +} + +void CFX_Matrix::SetReverse(const CFX_Matrix& m) { + float i = m.a * m.d - m.b * m.c; + if (fabs(i) == 0) + return; + + float j = -i; + a = m.d / i; + b = m.b / j; + c = m.c / j; + d = m.a / i; + e = (m.c * m.f - m.d * m.e) / i; + f = (m.a * m.f - m.b * m.e) / j; +} + +void CFX_Matrix::Concat(const CFX_Matrix& m, bool bPrepended) { + ConcatInternal(m, bPrepended); +} + +void CFX_Matrix::ConcatInverse(const CFX_Matrix& src, bool bPrepended) { + CFX_Matrix m; + m.SetReverse(src); + Concat(m, bPrepended); +} + +bool CFX_Matrix::Is90Rotated() const { + return fabs(a * 1000) < fabs(b) && fabs(d * 1000) < fabs(c); +} + +bool CFX_Matrix::IsScaled() const { + return fabs(b * 1000) < fabs(a) && fabs(c * 1000) < fabs(d); +} + +void CFX_Matrix::Translate(float x, float y, bool bPrepended) { + if (bPrepended) { + e += x * a + y * c; + f += y * d + x * b; + return; + } + e += x; + f += y; +} + +void CFX_Matrix::Scale(float sx, float sy, bool bPrepended) { + a *= sx; + d *= sy; + if (bPrepended) { + b *= sx; + c *= sy; + return; + } + + b *= sy; + c *= sx; + e *= sx; + f *= sy; +} + +void CFX_Matrix::Rotate(float fRadian, bool bPrepended) { + float cosValue = cos(fRadian); + float sinValue = sin(fRadian); + ConcatInternal(CFX_Matrix(cosValue, sinValue, -sinValue, cosValue, 0, 0), + bPrepended); +} + +void CFX_Matrix::RotateAt(float fRadian, float dx, float dy, bool bPrepended) { + Translate(dx, dy, bPrepended); + Rotate(fRadian, bPrepended); + Translate(-dx, -dy, bPrepended); +} + +void CFX_Matrix::Shear(float fAlphaRadian, float fBetaRadian, bool bPrepended) { + ConcatInternal(CFX_Matrix(1, tan(fAlphaRadian), tan(fBetaRadian), 1, 0, 0), + bPrepended); +} + +void CFX_Matrix::MatchRect(const CFX_FloatRect& dest, + const CFX_FloatRect& src) { + float fDiff = src.left - src.right; + a = fabs(fDiff) < 0.001f ? 1 : (dest.left - dest.right) / fDiff; + + fDiff = src.bottom - src.top; + d = fabs(fDiff) < 0.001f ? 1 : (dest.bottom - dest.top) / fDiff; + e = dest.left - src.left * a; + f = dest.bottom - src.bottom * d; + b = 0; + c = 0; +} + +float CFX_Matrix::GetXUnit() const { + if (b == 0) + return (a > 0 ? a : -a); + if (a == 0) + return (b > 0 ? b : -b); + return sqrt(a * a + b * b); +} + +float CFX_Matrix::GetYUnit() const { + if (c == 0) + return (d > 0 ? d : -d); + if (d == 0) + return (c > 0 ? c : -c); + return sqrt(c * c + d * d); +} + +CFX_FloatRect CFX_Matrix::GetUnitRect() const { + CFX_FloatRect rect(0, 0, 1, 1); + TransformRect(rect); + return rect; +} + +float CFX_Matrix::TransformXDistance(float dx) const { + float fx = a * dx; + float fy = b * dx; + return sqrt(fx * fx + fy * fy); +} + +float CFX_Matrix::TransformDistance(float dx, float dy) const { + float fx = a * dx + c * dy; + float fy = b * dx + d * dy; + return sqrt(fx * fx + fy * fy); +} + +float CFX_Matrix::TransformDistance(float distance) const { + return distance * (GetXUnit() + GetYUnit()) / 2; +} + +CFX_PointF CFX_Matrix::Transform(const CFX_PointF& point) const { + return CFX_PointF(a * point.x + c * point.y + e, + b * point.x + d * point.y + f); +} + +void CFX_Matrix::TransformRect(CFX_RectF& rect) const { + float right = rect.right(), bottom = rect.bottom(); + TransformRect(rect.left, right, bottom, rect.top); + rect.width = right - rect.left; + rect.height = bottom - rect.top; +} + +void CFX_Matrix::TransformRect(float& left, + float& right, + float& top, + float& bottom) const { + CFX_PointF points[] = { + {left, top}, {left, bottom}, {right, top}, {right, bottom}}; + for (int i = 0; i < 4; i++) + points[i] = Transform(points[i]); + + right = points[0].x; + left = points[0].x; + top = points[0].y; + bottom = points[0].y; + for (int i = 1; i < 4; i++) { + right = std::max(right, points[i].x); + left = std::min(left, points[i].x); + top = std::max(top, points[i].y); + bottom = std::min(bottom, points[i].y); + } +} + +void CFX_Matrix::ConcatInternal(const CFX_Matrix& other, bool prepend) { + CFX_Matrix left; + CFX_Matrix right; + if (prepend) { + left = other; + right = *this; + } else { + left = *this; + right = other; + } + + a = left.a * right.a + left.b * right.c; + b = left.a * right.b + left.b * right.d; + c = left.c * right.a + left.d * right.c; + d = left.c * right.b + left.d * right.d; + e = left.e * right.a + left.f * right.c + right.e; + f = left.e * right.b + left.f * right.d + right.f; +} -- cgit v1.2.3