1 /*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <math.h>
18
19 #include <cutils/compiler.h>
20 #include <utils/String8.h>
21 #include <ui/Region.h>
22
23 #include "Transform.h"
24
25 // ---------------------------------------------------------------------------
26
27 namespace android {
28
29 // ---------------------------------------------------------------------------
30
31 template <typename T>
min(T a,T b)32 static inline T min(T a, T b) {
33 return a<b ? a : b;
34 }
35 template <typename T>
min(T a,T b,T c)36 static inline T min(T a, T b, T c) {
37 return min(a, min(b, c));
38 }
39 template <typename T>
min(T a,T b,T c,T d)40 static inline T min(T a, T b, T c, T d) {
41 return min(a, b, min(c, d));
42 }
43
44 template <typename T>
max(T a,T b)45 static inline T max(T a, T b) {
46 return a>b ? a : b;
47 }
48 template <typename T>
max(T a,T b,T c)49 static inline T max(T a, T b, T c) {
50 return max(a, max(b, c));
51 }
52 template <typename T>
max(T a,T b,T c,T d)53 static inline T max(T a, T b, T c, T d) {
54 return max(a, b, max(c, d));
55 }
56
57 template <typename T>
58 static inline
swap(T & a,T & b)59 void swap(T& a, T& b) {
60 T t(a);
61 a = b;
62 b = t;
63 }
64
65 // ---------------------------------------------------------------------------
66
Transform()67 Transform::Transform() {
68 reset();
69 }
70
Transform(const Transform & other)71 Transform::Transform(const Transform& other)
72 : mMatrix(other.mMatrix), mType(other.mType) {
73 }
74
Transform(uint32_t orientation)75 Transform::Transform(uint32_t orientation) {
76 set(orientation, 0, 0);
77 }
78
~Transform()79 Transform::~Transform() {
80 }
81
82 static const float EPSILON = 0.0f;
83
isZero(float f)84 bool Transform::isZero(float f) {
85 return fabs(f) <= EPSILON;
86 }
87
absIsOne(float f)88 bool Transform::absIsOne(float f) {
89 return isZero(fabs(f) - 1.0f);
90 }
91
operator *(const Transform & rhs) const92 Transform Transform::operator * (const Transform& rhs) const
93 {
94 if (CC_LIKELY(mType == IDENTITY))
95 return rhs;
96
97 Transform r(*this);
98 if (rhs.mType == IDENTITY)
99 return r;
100
101 // TODO: we could use mType to optimize the matrix multiply
102 const mat33& A(mMatrix);
103 const mat33& B(rhs.mMatrix);
104 mat33& D(r.mMatrix);
105 for (int i=0 ; i<3 ; i++) {
106 const float v0 = A[0][i];
107 const float v1 = A[1][i];
108 const float v2 = A[2][i];
109 D[0][i] = v0*B[0][0] + v1*B[0][1] + v2*B[0][2];
110 D[1][i] = v0*B[1][0] + v1*B[1][1] + v2*B[1][2];
111 D[2][i] = v0*B[2][0] + v1*B[2][1] + v2*B[2][2];
112 }
113 r.mType |= rhs.mType;
114
115 // TODO: we could recompute this value from r and rhs
116 r.mType &= 0xFF;
117 r.mType |= UNKNOWN_TYPE;
118 return r;
119 }
120
operator [](int i) const121 float const* Transform::operator [] (int i) const {
122 return mMatrix[i].v;
123 }
124
transformed() const125 bool Transform::transformed() const {
126 return type() > TRANSLATE;
127 }
128
tx() const129 int Transform::tx() const {
130 return floorf(mMatrix[2][0] + 0.5f);
131 }
132
ty() const133 int Transform::ty() const {
134 return floorf(mMatrix[2][1] + 0.5f);
135 }
136
reset()137 void Transform::reset() {
138 mType = IDENTITY;
139 for(int i=0 ; i<3 ; i++) {
140 vec3& v(mMatrix[i]);
141 for (int j=0 ; j<3 ; j++)
142 v[j] = ((i==j) ? 1.0f : 0.0f);
143 }
144 }
145
set(float tx,float ty)146 void Transform::set(float tx, float ty)
147 {
148 mMatrix[2][0] = tx;
149 mMatrix[2][1] = ty;
150 mMatrix[2][2] = 1.0f;
151
152 if (isZero(tx) && isZero(ty)) {
153 mType &= ~TRANSLATE;
154 } else {
155 mType |= TRANSLATE;
156 }
157 }
158
set(float a,float b,float c,float d)159 void Transform::set(float a, float b, float c, float d)
160 {
161 mat33& M(mMatrix);
162 M[0][0] = a; M[1][0] = b;
163 M[0][1] = c; M[1][1] = d;
164 M[0][2] = 0; M[1][2] = 0;
165 mType = UNKNOWN_TYPE;
166 }
167
set(uint32_t flags,float w,float h)168 status_t Transform::set(uint32_t flags, float w, float h)
169 {
170 if (flags & ROT_INVALID) {
171 // that's not allowed!
172 reset();
173 return BAD_VALUE;
174 }
175
176 Transform H, V, R;
177 if (flags & ROT_90) {
178 // w & h are inverted when rotating by 90 degrees
179 swap(w, h);
180 }
181
182 if (flags & FLIP_H) {
183 H.mType = (FLIP_H << 8) | SCALE;
184 H.mType |= isZero(w) ? IDENTITY : TRANSLATE;
185 mat33& M(H.mMatrix);
186 M[0][0] = -1;
187 M[2][0] = w;
188 }
189
190 if (flags & FLIP_V) {
191 V.mType = (FLIP_V << 8) | SCALE;
192 V.mType |= isZero(h) ? IDENTITY : TRANSLATE;
193 mat33& M(V.mMatrix);
194 M[1][1] = -1;
195 M[2][1] = h;
196 }
197
198 if (flags & ROT_90) {
199 const float original_w = h;
200 R.mType = (ROT_90 << 8) | ROTATE;
201 R.mType |= isZero(original_w) ? IDENTITY : TRANSLATE;
202 mat33& M(R.mMatrix);
203 M[0][0] = 0; M[1][0] =-1; M[2][0] = original_w;
204 M[0][1] = 1; M[1][1] = 0;
205 }
206
207 *this = (R*(H*V));
208 return NO_ERROR;
209 }
210
transform(const vec2 & v) const211 Transform::vec2 Transform::transform(const vec2& v) const {
212 vec2 r;
213 const mat33& M(mMatrix);
214 r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0];
215 r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1];
216 return r;
217 }
218
transform(const vec3 & v) const219 Transform::vec3 Transform::transform(const vec3& v) const {
220 vec3 r;
221 const mat33& M(mMatrix);
222 r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]*v[2];
223 r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]*v[2];
224 r[2] = M[0][2]*v[0] + M[1][2]*v[1] + M[2][2]*v[2];
225 return r;
226 }
227
transform(float * point,int x,int y) const228 void Transform::transform(float* point, int x, int y) const
229 {
230 const mat33& M(mMatrix);
231 vec2 v(x, y);
232 v = transform(v);
233 point[0] = v[0];
234 point[1] = v[1];
235 }
236
makeBounds(int w,int h) const237 Rect Transform::makeBounds(int w, int h) const
238 {
239 return transform( Rect(w, h) );
240 }
241
transform(const Rect & bounds) const242 Rect Transform::transform(const Rect& bounds) const
243 {
244 Rect r;
245 vec2 lt( bounds.left, bounds.top );
246 vec2 rt( bounds.right, bounds.top );
247 vec2 lb( bounds.left, bounds.bottom );
248 vec2 rb( bounds.right, bounds.bottom );
249
250 lt = transform(lt);
251 rt = transform(rt);
252 lb = transform(lb);
253 rb = transform(rb);
254
255 r.left = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
256 r.top = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
257 r.right = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
258 r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
259
260 return r;
261 }
262
transform(const Region & reg) const263 Region Transform::transform(const Region& reg) const
264 {
265 Region out;
266 if (CC_UNLIKELY(transformed())) {
267 if (CC_LIKELY(preserveRects())) {
268 Region::const_iterator it = reg.begin();
269 Region::const_iterator const end = reg.end();
270 while (it != end) {
271 out.orSelf(transform(*it++));
272 }
273 } else {
274 out.set(transform(reg.bounds()));
275 }
276 } else {
277 out = reg.translate(tx(), ty());
278 }
279 return out;
280 }
281
type() const282 uint32_t Transform::type() const
283 {
284 if (mType & UNKNOWN_TYPE) {
285 // recompute what this transform is
286
287 const mat33& M(mMatrix);
288 const float a = M[0][0];
289 const float b = M[1][0];
290 const float c = M[0][1];
291 const float d = M[1][1];
292 const float x = M[2][0];
293 const float y = M[2][1];
294
295 bool scale = false;
296 uint32_t flags = ROT_0;
297 if (isZero(b) && isZero(c)) {
298 if (a<0) flags |= FLIP_H;
299 if (d<0) flags |= FLIP_V;
300 if (!absIsOne(a) || !absIsOne(d)) {
301 scale = true;
302 }
303 } else if (isZero(a) && isZero(d)) {
304 flags |= ROT_90;
305 if (b>0) flags |= FLIP_V;
306 if (c<0) flags |= FLIP_H;
307 if (!absIsOne(b) || !absIsOne(c)) {
308 scale = true;
309 }
310 } else {
311 flags = ROT_INVALID;
312 }
313
314 mType = flags << 8;
315 if (flags & ROT_INVALID) {
316 mType |= UNKNOWN;
317 } else {
318 if ((flags & ROT_90) || ((flags & ROT_180) == ROT_180))
319 mType |= ROTATE;
320 if (flags & FLIP_H)
321 mType ^= SCALE;
322 if (flags & FLIP_V)
323 mType ^= SCALE;
324 if (scale)
325 mType |= SCALE;
326 }
327
328 if (!isZero(x) || !isZero(y))
329 mType |= TRANSLATE;
330 }
331 return mType;
332 }
333
getType() const334 uint32_t Transform::getType() const {
335 return type() & 0xFF;
336 }
337
getOrientation() const338 uint32_t Transform::getOrientation() const
339 {
340 return (type() >> 8) & 0xFF;
341 }
342
preserveRects() const343 bool Transform::preserveRects() const
344 {
345 return (type() & ROT_INVALID) ? false : true;
346 }
347
dump(const char * name) const348 void Transform::dump(const char* name) const
349 {
350 type(); // updates the type
351
352 String8 flags, type;
353 const mat33& m(mMatrix);
354 uint32_t orient = mType >> 8;
355
356 if (orient&ROT_INVALID) {
357 flags.append("ROT_INVALID ");
358 } else {
359 if (orient&ROT_90) {
360 flags.append("ROT_90 ");
361 } else {
362 flags.append("ROT_0 ");
363 }
364 if (orient&FLIP_V)
365 flags.append("FLIP_V ");
366 if (orient&FLIP_H)
367 flags.append("FLIP_H ");
368 }
369
370 if (!(mType&(SCALE|ROTATE|TRANSLATE)))
371 type.append("IDENTITY ");
372 if (mType&SCALE)
373 type.append("SCALE ");
374 if (mType&ROTATE)
375 type.append("ROTATE ");
376 if (mType&TRANSLATE)
377 type.append("TRANSLATE ");
378
379 LOGD("%s 0x%08x (%s, %s)", name, mType, flags.string(), type.string());
380 LOGD("%.4f %.4f %.4f", m[0][0], m[1][0], m[2][0]);
381 LOGD("%.4f %.4f %.4f", m[0][1], m[1][1], m[2][1]);
382 LOGD("%.4f %.4f %.4f", m[0][2], m[1][2], m[2][2]);
383 }
384
385 // ---------------------------------------------------------------------------
386
387 }; // namespace android
388