hrev52816 adds 1 changeset to branch 'master'
old head: cf77ef1857e4b8fc90b4a45b717251d5cef08a80
new head: d1f885b435e9892ac028f4be2b80536b9dd37413
overview:
https://git.haiku-os.org/haiku/log/?qt=range&q=d1f885b435e9+%5Ecf77ef1857e4
----------------------------------------------------------------------------
d1f885b435e9: headers/libs/agg Fix PVS 11, PVS12
* Replace hard-coded math constants with M_SQRT1_2
(math.h was already included)
* also trailing whitespace removal
Change-Id: I5e9511060d2f812830f7621bee3aff9a517576e5
Reviewed-on: https://review.haiku-os.org/c/956
Reviewed-by: waddlesplash <waddlesplash@xxxxxxxxx>
[ Rob Gill <rrobgill@xxxxxxxxxxxxxx> ]
----------------------------------------------------------------------------
Revision: hrev52816
Commit: d1f885b435e9892ac028f4be2b80536b9dd37413
URL: https://git.haiku-os.org/haiku/commit/?id=d1f885b435e9
Author: Rob Gill <rrobgill@xxxxxxxxxxxxxx>
Date: Mon Jan 28 02:26:26 2019 UTC
Committer: waddlesplash <waddlesplash@xxxxxxxxx>
Commit-Date: Tue Jan 29 04:02:25 2019 UTC
----------------------------------------------------------------------------
1 file changed, 47 insertions(+), 47 deletions(-)
headers/libs/agg/agg_trans_affine.h | 94 ++++++++++++++++-----------------
----------------------------------------------------------------------------
diff --git a/headers/libs/agg/agg_trans_affine.h
b/headers/libs/agg/agg_trans_affine.h
index ea5d9cf999..b3304e9a32 100644
--- a/headers/libs/agg/agg_trans_affine.h
+++ b/headers/libs/agg/agg_trans_affine.h
@@ -2,8 +2,8 @@
// Anti-Grain Geometry - Version 2.4
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
@@ -31,32 +31,32 @@ namespace agg
// See Implementation agg_trans_affine.cpp
//
// Affine transformation are linear transformations in Cartesian
coordinates
- // (strictly speaking not only in Cartesian, but for the beginning we will
- // think so). They are rotation, scaling, translation and skewing.
- // After any affine transformation a line segment remains a line segment
- // and it will never become a curve.
+ // (strictly speaking not only in Cartesian, but for the beginning we will
+ // think so). They are rotation, scaling, translation and skewing.
+ // After any affine transformation a line segment remains a line segment
+ // and it will never become a curve.
//
- // There will be no math about matrix calculations, since it has been
+ // There will be no math about matrix calculations, since it has been
// described many times. Ask yourself a very simple question:
- // "why do we need to understand and use some matrix stuff instead of just
+ // "why do we need to understand and use some matrix stuff instead of just
// rotating, scaling and so on". The answers are:
//
// 1. Any combination of transformations can be done by only 4
multiplications
// and 4 additions in floating point.
// 2. One matrix transformation is equivalent to the number of consecutive
- // discrete transformations, i.e. the matrix "accumulates" all
transformations
- // in the order of their settings. Suppose we have 4 transformations:
+ // discrete transformations, i.e. the matrix "accumulates" all
transformations
+ // in the order of their settings. Suppose we have 4 transformations:
// * rotate by 30 degrees,
- // * scale X to 2.0,
- // * scale Y to 1.5,
- // * move to (100, 100).
- // The result will depend on the order of these transformations,
+ // * scale X to 2.0,
+ // * scale Y to 1.5,
+ // * move to (100, 100).
+ // The result will depend on the order of these transformations,
// and the advantage of matrix is that the sequence of discret calls:
- // rotate(30), scaleX(2.0), scaleY(1.5), move(100,100)
+ // rotate(30), scaleX(2.0), scaleY(1.5), move(100,100)
// will have exactly the same result as the following matrix
transformations:
- //
+ //
// affine_matrix m;
- // m *= rotate_matrix(30);
+ // m *= rotate_matrix(30);
// m *= scaleX_matrix(2.0);
// m *= scaleY_matrix(1.5);
// m *= move_matrix(100,100);
@@ -64,7 +64,7 @@ namespace agg
// m.transform_my_point_at_last(x, y);
//
// What is the good of it? In real life we will set-up the matrix only once
- // and then transform many points, let alone the convenience to set any
+ // and then transform many points, let alone the convenience to set any
// combination of transformations.
//
// So, how to use it? Very easy - literally as it's shown above. Not quite,
@@ -77,9 +77,9 @@ namespace agg
// m.transform(&x, &y);
//
// The affine matrix is all you need to perform any linear transformation,
- // but all transformations have origin point (0,0). It means that we need
to
+ // but all transformations have origin point (0,0). It means that we need
to
// use 2 translations if we want to rotate someting around (100,100):
- //
+ //
// m *= agg::trans_affine_translation(-100.0, -100.0); // move to
(0,0)
// m *= agg::trans_affine_rotation(30.0 * 3.1415926 / 180.0); // rotate
// m *= agg::trans_affine_translation(100.0, 100.0); // move
back to (100,100)
@@ -105,14 +105,14 @@ namespace agg
}
// Construct a matrix to transform a rectangle to a parallelogram.
- trans_affine(double x1, double y1, double x2, double y2,
+ trans_affine(double x1, double y1, double x2, double y2,
const double* parl)
{
rect_to_parl(x1, y1, x2, y2, parl);
}
// Construct a matrix to transform a parallelogram to a rectangle.
- trans_affine(const double* parl,
+ trans_affine(const double* parl,
double x1, double y1, double x2, double y2)
{
parl_to_rect(parl, x1, y1, x2, y2);
@@ -121,20 +121,20 @@ namespace agg
//---------------------------------- Parellelogram transformations
// Calculate a matrix to transform a parallelogram to another one.
- // src and dst are pointers to arrays of three points
- // (double[6], x,y,...) that identify three corners of the
+ // src and dst are pointers to arrays of three points
+ // (double[6], x,y,...) that identify three corners of the
// parallelograms assuming implicit fourth points.
- // There are also transformations rectangtle to parallelogram and
+ // There are also transformations rectangtle to parallelogram and
// parellelogram to rectangle
- const trans_affine& parl_to_parl(const double* src,
+ const trans_affine& parl_to_parl(const double* src,
const double* dst);
- const trans_affine& rect_to_parl(double x1, double y1,
- double x2, double y2,
+ const trans_affine& rect_to_parl(double x1, double y1,
+ double x2, double y2,
const double* parl);
- const trans_affine& parl_to_rect(const double* parl,
- double x1, double y1,
+ const trans_affine& parl_to_rect(const double* parl,
+ double x1, double y1,
double x2, double y2);
@@ -154,8 +154,8 @@ namespace agg
// Multiply inverse of "m" to "this" and assign the result to "this"
const trans_affine& premultiply_inv(const trans_affine& m);
- // Invert matrix. Do not try to invert degenerate matrices,
- // there's no check for validity. If you set scale to 0 and
+ // Invert matrix. Do not try to invert degenerate matrices,
+ // there's no check for validity. If you set scale to 0 and
// then try to invert matrix, expect unpredictable result.
const trans_affine& invert();
@@ -180,7 +180,7 @@ namespace agg
}
//------------------------------------------- Operators
-
+
// Multiply current matrix to another one
const trans_affine& operator *= (const trans_affine& m)
{
@@ -200,7 +200,7 @@ namespace agg
return trans_affine(*this).multiply(m);
}
- // Multiply current matrix to inverse of another one
+ // Multiply current matrix to inverse of another one
// and return the result in a separete matrix.
trans_affine operator / (const trans_affine& m) const
{
@@ -233,8 +233,8 @@ namespace agg
// Direct transformation x and y, 2x2 matrix only, no translation
void transform_2x2(double* x, double* y) const;
- // Inverse transformation x and y. It works slower than the
- // direct transformation, so if the performance is critical
+ // Inverse transformation x and y. It works slower than the
+ // direct transformation, so if the performance is critical
// it's better to invert() the matrix and then use transform()
void inverse_transform(double* x, double* y) const;
@@ -245,7 +245,7 @@ namespace agg
return 1.0 / (m0 * m3 - m1 * m2);
}
- // Get the average scale (by X and Y).
+ // Get the average scale (by X and Y).
// Basically used to calculate the approximation_scale when
// decomposinting curves into line segments.
double scale() const;
@@ -304,8 +304,8 @@ namespace agg
//------------------------------------------------------------------------
inline double trans_affine::scale() const
{
- double x = 0.707106781 * m0 + 0.707106781 * m2;
- double y = 0.707106781 * m1 + 0.707106781 * m3;
+ double x = M_SQRT1_2 * m0 + M_SQRT1_2 * m2;
+ double y = M_SQRT1_2 * m1 + M_SQRT1_2 * m3;
return sqrt(x*x + y*y);
}
@@ -336,12 +336,12 @@ namespace agg
//====================================================trans_affine_rotation
// Rotation matrix. sin() and cos() are calculated twice for the same
angle.
// There's no harm because the performance of sin()/cos() is very good on
all
- // modern processors. Besides, this operation is not going to be invoked
too
+ // modern processors. Besides, this operation is not going to be invoked
too
// often.
class trans_affine_rotation : public trans_affine
{
public:
- trans_affine_rotation(double a) :
+ trans_affine_rotation(double a) :
trans_affine(cos(a), sin(a), -sin(a), cos(a), 0.0, 0.0)
{}
};
@@ -351,11 +351,11 @@ namespace agg
class trans_affine_scaling : public trans_affine
{
public:
- trans_affine_scaling(double sx, double sy) :
+ trans_affine_scaling(double sx, double sy) :
trans_affine(sx, 0.0, 0.0, sy, 0.0, 0.0)
{}
- trans_affine_scaling(double s) :
+ trans_affine_scaling(double s) :
trans_affine(s, 0.0, 0.0, s, 0.0, 0.0)
{}
};
@@ -365,7 +365,7 @@ namespace agg
class trans_affine_translation : public trans_affine
{
public:
- trans_affine_translation(double tx, double ty) :
+ trans_affine_translation(double tx, double ty) :
trans_affine(1.0, 0.0, 0.0, 1.0, tx, ty)
{}
};
@@ -375,19 +375,19 @@ namespace agg
class trans_affine_skewing : public trans_affine
{
public:
- trans_affine_skewing(double sx, double sy) :
+ trans_affine_skewing(double sx, double sy) :
trans_affine(1.0, tan(sy), tan(sx), 1.0, 0.0, 0.0)
{}
};
//===============================================trans_affine_line_segment
- // Rotate, Scale and Translate, associating 0...dist with line segment
+ // Rotate, Scale and Translate, associating 0...dist with line segment
// x1,y1,x2,y2
class trans_affine_line_segment : public trans_affine
{
public:
- trans_affine_line_segment(double x1, double y1, double x2, double y2,
+ trans_affine_line_segment(double x1, double y1, double x2, double y2,
double dist)
{
double dx = x2 - x1;
