← Back to branch summary

~s-cecilio/lomse/master

« back to all changes in this revision

Viewing changes to src/agg/src/agg_trans_affine.cpp

  • Committer: cecilios
  • Date: 2010-11-14 17:47:31 UTC
  • Revision ID: git-v1:1fa3764c8c4d338b95b1a537b1e78271170c0025
latest new code. demo_1 tested on linux and win32

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/agg/src/agg_trans_affine.cpp
 
1
//----------------------------------------------------------------------------
 
2
// Anti-Grain Geometry - Version 2.4
 
3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 
4
//
 
5
// Permission to copy, use, modify, sell and distribute this software 
 
6
// is granted provided this copyright notice appears in all copies. 
 
7
// This software is provided "as is" without express or implied
 
8
// warranty, and with no claim as to its suitability for any purpose.
 
9
//
 
10
//----------------------------------------------------------------------------
 
11
// Contact: mcseem@antigrain.com
 
12
//          mcseemagg@yahoo.com
 
13
//          http://www.antigrain.com
 
14
//----------------------------------------------------------------------------
 
15
//
 
16
// Affine transformations
 
17
//
 
18
//----------------------------------------------------------------------------
 
19
#include "agg_trans_affine.h"
 
20
 
 
21
 
 
22
 
 
23
namespace agg
 
24
{
 
25
 
 
26
    //------------------------------------------------------------------------
 
27
    const trans_affine& trans_affine::parl_to_parl(const double* src, 
 
28
                                                   const double* dst)
 
29
    {
 
30
        sx  = src[2] - src[0];
 
31
        shy = src[3] - src[1];
 
32
        shx = src[4] - src[0];
 
33
        sy  = src[5] - src[1];
 
34
        tx  = src[0];
 
35
        ty  = src[1];
 
36
        invert();
 
37
        multiply(trans_affine(dst[2] - dst[0], dst[3] - dst[1], 
 
38
                              dst[4] - dst[0], dst[5] - dst[1],
 
39
                              dst[0], dst[1]));
 
40
        return *this;
 
41
    }
 
42
 
 
43
    //------------------------------------------------------------------------
 
44
    const trans_affine& trans_affine::rect_to_parl(double x1, double y1, 
 
45
                                                   double x2, double y2, 
 
46
                                                   const double* parl)
 
47
    {
 
48
        double src[6];
 
49
        src[0] = x1; src[1] = y1;
 
50
        src[2] = x2; src[3] = y1;
 
51
        src[4] = x2; src[5] = y2;
 
52
        parl_to_parl(src, parl);
 
53
        return *this;
 
54
    }
 
55
 
 
56
    //------------------------------------------------------------------------
 
57
    const trans_affine& trans_affine::parl_to_rect(const double* parl, 
 
58
                                                   double x1, double y1, 
 
59
                                                   double x2, double y2)
 
60
    {
 
61
        double dst[6];
 
62
        dst[0] = x1; dst[1] = y1;
 
63
        dst[2] = x2; dst[3] = y1;
 
64
        dst[4] = x2; dst[5] = y2;
 
65
        parl_to_parl(parl, dst);
 
66
        return *this;
 
67
    }
 
68
 
 
69
    //------------------------------------------------------------------------
 
70
    const trans_affine& trans_affine::multiply(const trans_affine& m)
 
71
    {
 
72
        double t0 = sx  * m.sx + shy * m.shx;
 
73
        double t2 = shx * m.sx + sy  * m.shx;
 
74
        double t4 = tx  * m.sx + ty  * m.shx + m.tx;
 
75
        shy = sx  * m.shy + shy * m.sy;
 
76
        sy  = shx * m.shy + sy  * m.sy;
 
77
        ty  = tx  * m.shy + ty  * m.sy + m.ty;
 
78
        sx  = t0;
 
79
        shx = t2;
 
80
        tx  = t4;
 
81
        return *this;
 
82
    }
 
83
 
 
84
 
 
85
    //------------------------------------------------------------------------
 
86
    const trans_affine& trans_affine::invert()
 
87
    {
 
88
        double d  = determinant_reciprocal();
 
89
 
 
90
        double t0  =  sy  * d;
 
91
               sy  =  sx  * d;
 
92
               shy = -shy * d;
 
93
               shx = -shx * d;
 
94
 
 
95
        double t4 = -tx * t0  - ty * shx;
 
96
               ty = -tx * shy - ty * sy;
 
97
 
 
98
        sx = t0;
 
99
        tx = t4;
 
100
        return *this;
 
101
    }
 
102
 
 
103
 
 
104
   //------------------------------------------------------------------------
 
105
    const trans_affine& trans_affine::flip_x()
 
106
    {
 
107
        sx  = -sx;
 
108
        shy = -shy;
 
109
        tx  = -tx;
 
110
        return *this;
 
111
    }
 
112
 
 
113
    //------------------------------------------------------------------------
 
114
    const trans_affine& trans_affine::flip_y()
 
115
    {
 
116
        shx = -shx;
 
117
        sy  = -sy;
 
118
        ty  = -ty;
 
119
        return *this;
 
120
    }
 
121
 
 
122
    //------------------------------------------------------------------------
 
123
    const trans_affine& trans_affine::reset()
 
124
    {
 
125
        sx  = sy  = 1.0; 
 
126
        shy = shx = tx = ty = 0.0;
 
127
        return *this;
 
128
    }
 
129
 
 
130
    //------------------------------------------------------------------------
 
131
    bool trans_affine::is_identity(double epsilon) const
 
132
    {
 
133
        return is_equal_eps(sx,  1.0, epsilon) &&
 
134
               is_equal_eps(shy, 0.0, epsilon) &&
 
135
               is_equal_eps(shx, 0.0, epsilon) && 
 
136
               is_equal_eps(sy,  1.0, epsilon) &&
 
137
               is_equal_eps(tx,  0.0, epsilon) &&
 
138
               is_equal_eps(ty,  0.0, epsilon);
 
139
    }
 
140
 
 
141
    //------------------------------------------------------------------------
 
142
    bool trans_affine::is_valid(double epsilon) const
 
143
    {
 
144
        return fabs(sx) > epsilon && fabs(sy) > epsilon;
 
145
    }
 
146
 
 
147
    //------------------------------------------------------------------------
 
148
    bool trans_affine::is_equal(const trans_affine& m, double epsilon) const
 
149
    {
 
150
        return is_equal_eps(sx,  m.sx,  epsilon) &&
 
151
               is_equal_eps(shy, m.shy, epsilon) &&
 
152
               is_equal_eps(shx, m.shx, epsilon) && 
 
153
               is_equal_eps(sy,  m.sy,  epsilon) &&
 
154
               is_equal_eps(tx,  m.tx,  epsilon) &&
 
155
               is_equal_eps(ty,  m.ty,  epsilon);
 
156
    }
 
157
 
 
158
    //------------------------------------------------------------------------
 
159
    double trans_affine::rotation() const
 
160
    {
 
161
        double x1 = 0.0;
 
162
        double y1 = 0.0;
 
163
        double x2 = 1.0;
 
164
        double y2 = 0.0;
 
165
        transform(&x1, &y1);
 
166
        transform(&x2, &y2);
 
167
        return atan2(y2-y1, x2-x1);
 
168
    }
 
169
 
 
170
    //------------------------------------------------------------------------
 
171
    void trans_affine::translation(double* dx, double* dy) const
 
172
    {
 
173
        *dx = tx;
 
174
        *dy = ty;
 
175
    }
 
176
 
 
177
    //------------------------------------------------------------------------
 
178
    void trans_affine::scaling(double* x, double* y) const
 
179
    {
 
180
        double x1 = 0.0;
 
181
        double y1 = 0.0;
 
182
        double x2 = 1.0;
 
183
        double y2 = 1.0;
 
184
        trans_affine t(*this);
 
185
        t *= trans_affine_rotation(-rotation());
 
186
        t.transform(&x1, &y1);
 
187
        t.transform(&x2, &y2);
 
188
        *x = x2 - x1;
 
189
        *y = y2 - y1;
 
190
    }
 
191
 
 
192
 
 
193
}
 
194