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 "clz.h"
24#include "Transform.h"
25
26// ---------------------------------------------------------------------------
27
28namespace android {
29
30// ---------------------------------------------------------------------------
31
32Transform::Transform() {
33    reset();
34}
35
36Transform::Transform(const Transform&  other)
37    : mMatrix(other.mMatrix), mType(other.mType) {
38}
39
40Transform::Transform(uint32_t orientation) {
41    set(orientation, 0, 0);
42}
43
44Transform::~Transform() {
45}
46
47static const float EPSILON = 0.0f;
48
49bool Transform::isZero(float f) {
50    return fabs(f) <= EPSILON;
51}
52
53bool Transform::absIsOne(float f) {
54    return isZero(fabs(f) - 1.0f);
55}
56
57Transform Transform::operator * (const Transform& rhs) const
58{
59    if (CC_LIKELY(mType == IDENTITY))
60        return rhs;
61
62    Transform r(*this);
63    if (rhs.mType == IDENTITY)
64        return r;
65
66    // TODO: we could use mType to optimize the matrix multiply
67    const mat33& A(mMatrix);
68    const mat33& B(rhs.mMatrix);
69          mat33& D(r.mMatrix);
70    for (int i=0 ; i<3 ; i++) {
71        const float v0 = A[0][i];
72        const float v1 = A[1][i];
73        const float v2 = A[2][i];
74        D[0][i] = v0*B[0][0] + v1*B[0][1] + v2*B[0][2];
75        D[1][i] = v0*B[1][0] + v1*B[1][1] + v2*B[1][2];
76        D[2][i] = v0*B[2][0] + v1*B[2][1] + v2*B[2][2];
77    }
78    r.mType |= rhs.mType;
79
80    // TODO: we could recompute this value from r and rhs
81    r.mType &= 0xFF;
82    r.mType |= UNKNOWN_TYPE;
83    return r;
84}
85
86const vec3& Transform::operator [] (size_t i) const {
87    return mMatrix[i];
88}
89
90float Transform::tx() const {
91    return mMatrix[2][0];
92}
93
94float Transform::ty() const {
95    return mMatrix[2][1];
96}
97
98void Transform::reset() {
99    mType = IDENTITY;
100    for(int i=0 ; i<3 ; i++) {
101        vec3& v(mMatrix[i]);
102        for (int j=0 ; j<3 ; j++)
103            v[j] = ((i==j) ? 1.0f : 0.0f);
104    }
105}
106
107void Transform::set(float tx, float ty)
108{
109    mMatrix[2][0] = tx;
110    mMatrix[2][1] = ty;
111    mMatrix[2][2] = 1.0f;
112
113    if (isZero(tx) && isZero(ty)) {
114        mType &= ~TRANSLATE;
115    } else {
116        mType |= TRANSLATE;
117    }
118}
119
120void Transform::set(float a, float b, float c, float d)
121{
122    mat33& M(mMatrix);
123    M[0][0] = a;    M[1][0] = b;
124    M[0][1] = c;    M[1][1] = d;
125    M[0][2] = 0;    M[1][2] = 0;
126    mType = UNKNOWN_TYPE;
127}
128
129status_t Transform::set(uint32_t flags, float w, float h)
130{
131    if (flags & ROT_INVALID) {
132        // that's not allowed!
133        reset();
134        return BAD_VALUE;
135    }
136
137    Transform H, V, R;
138    if (flags & ROT_90) {
139        // w & h are inverted when rotating by 90 degrees
140        swap(w, h);
141    }
142
143    if (flags & FLIP_H) {
144        H.mType = (FLIP_H << 8) | SCALE;
145        H.mType |= isZero(w) ? IDENTITY : TRANSLATE;
146        mat33& M(H.mMatrix);
147        M[0][0] = -1;
148        M[2][0] = w;
149    }
150
151    if (flags & FLIP_V) {
152        V.mType = (FLIP_V << 8) | SCALE;
153        V.mType |= isZero(h) ? IDENTITY : TRANSLATE;
154        mat33& M(V.mMatrix);
155        M[1][1] = -1;
156        M[2][1] = h;
157    }
158
159    if (flags & ROT_90) {
160        const float original_w = h;
161        R.mType = (ROT_90 << 8) | ROTATE;
162        R.mType |= isZero(original_w) ? IDENTITY : TRANSLATE;
163        mat33& M(R.mMatrix);
164        M[0][0] = 0;    M[1][0] =-1;    M[2][0] = original_w;
165        M[0][1] = 1;    M[1][1] = 0;
166    }
167
168    *this = (R*(H*V));
169    return NO_ERROR;
170}
171
172vec2 Transform::transform(const vec2& v) const {
173    vec2 r;
174    const mat33& M(mMatrix);
175    r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0];
176    r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1];
177    return r;
178}
179
180vec3 Transform::transform(const vec3& v) const {
181    vec3 r;
182    const mat33& M(mMatrix);
183    r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]*v[2];
184    r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]*v[2];
185    r[2] = M[0][2]*v[0] + M[1][2]*v[1] + M[2][2]*v[2];
186    return r;
187}
188
189vec2 Transform::transform(int x, int y) const
190{
191    return transform(vec2(x,y));
192}
193
194Rect Transform::makeBounds(int w, int h) const
195{
196    return transform( Rect(w, h) );
197}
198
199Rect Transform::transform(const Rect& bounds, bool roundOutwards) const
200{
201    Rect r;
202    vec2 lt( bounds.left,  bounds.top    );
203    vec2 rt( bounds.right, bounds.top    );
204    vec2 lb( bounds.left,  bounds.bottom );
205    vec2 rb( bounds.right, bounds.bottom );
206
207    lt = transform(lt);
208    rt = transform(rt);
209    lb = transform(lb);
210    rb = transform(rb);
211
212    if (roundOutwards) {
213        r.left   = floorf(min(lt[0], rt[0], lb[0], rb[0]));
214        r.top    = floorf(min(lt[1], rt[1], lb[1], rb[1]));
215        r.right  = ceilf(max(lt[0], rt[0], lb[0], rb[0]));
216        r.bottom = ceilf(max(lt[1], rt[1], lb[1], rb[1]));
217    } else {
218        r.left   = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
219        r.top    = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
220        r.right  = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f);
221        r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f);
222    }
223
224    return r;
225}
226
227Region Transform::transform(const Region& reg) const
228{
229    Region out;
230    if (CC_UNLIKELY(type() > TRANSLATE)) {
231        if (CC_LIKELY(preserveRects())) {
232            Region::const_iterator it = reg.begin();
233            Region::const_iterator const end = reg.end();
234            while (it != end) {
235                out.orSelf(transform(*it++));
236            }
237        } else {
238            out.set(transform(reg.bounds()));
239        }
240    } else {
241        int xpos = floorf(tx() + 0.5f);
242        int ypos = floorf(ty() + 0.5f);
243        out = reg.translate(xpos, ypos);
244    }
245    return out;
246}
247
248uint32_t Transform::type() const
249{
250    if (mType & UNKNOWN_TYPE) {
251        // recompute what this transform is
252
253        const mat33& M(mMatrix);
254        const float a = M[0][0];
255        const float b = M[1][0];
256        const float c = M[0][1];
257        const float d = M[1][1];
258        const float x = M[2][0];
259        const float y = M[2][1];
260
261        bool scale = false;
262        uint32_t flags = ROT_0;
263        if (isZero(b) && isZero(c)) {
264            if (a<0)    flags |= FLIP_H;
265            if (d<0)    flags |= FLIP_V;
266            if (!absIsOne(a) || !absIsOne(d)) {
267                scale = true;
268            }
269        } else if (isZero(a) && isZero(d)) {
270            flags |= ROT_90;
271            if (b>0)    flags |= FLIP_V;
272            if (c<0)    flags |= FLIP_H;
273            if (!absIsOne(b) || !absIsOne(c)) {
274                scale = true;
275            }
276        } else {
277            // there is a skew component and/or a non 90 degrees rotation
278            flags = ROT_INVALID;
279        }
280
281        mType = flags << 8;
282        if (flags & ROT_INVALID) {
283            mType |= UNKNOWN;
284        } else {
285            if ((flags & ROT_90) || ((flags & ROT_180) == ROT_180))
286                mType |= ROTATE;
287            if (flags & FLIP_H)
288                mType ^= SCALE;
289            if (flags & FLIP_V)
290                mType ^= SCALE;
291            if (scale)
292                mType |= SCALE;
293        }
294
295        if (!isZero(x) || !isZero(y))
296            mType |= TRANSLATE;
297    }
298    return mType;
299}
300
301Transform Transform::inverse() const {
302    // our 3x3 matrix is always of the form of a 2x2 transformation
303    // followed by a translation: T*M, therefore:
304    // (T*M)^-1 = M^-1 * T^-1
305    Transform result;
306    if (mType <= TRANSLATE) {
307        // 1 0 0
308        // 0 1 0
309        // x y 1
310        result = *this;
311        result.mMatrix[2][0] = -result.mMatrix[2][0];
312        result.mMatrix[2][1] = -result.mMatrix[2][1];
313    } else {
314        // a c 0
315        // b d 0
316        // x y 1
317        const mat33& M(mMatrix);
318        const float a = M[0][0];
319        const float b = M[1][0];
320        const float c = M[0][1];
321        const float d = M[1][1];
322        const float x = M[2][0];
323        const float y = M[2][1];
324
325        const float idet = 1.0 / (a*d - b*c);
326        result.mMatrix[0][0] =  d*idet;
327        result.mMatrix[0][1] = -c*idet;
328        result.mMatrix[1][0] = -b*idet;
329        result.mMatrix[1][1] =  a*idet;
330        result.mType = mType;
331
332        vec2 T(-x, -y);
333        T = result.transform(T);
334        result.mMatrix[2][0] = T[0];
335        result.mMatrix[2][1] = T[1];
336    }
337    return result;
338}
339
340uint32_t Transform::getType() const {
341    return type() & 0xFF;
342}
343
344uint32_t Transform::getOrientation() const
345{
346    return (type() >> 8) & 0xFF;
347}
348
349bool Transform::preserveRects() const
350{
351    return (getOrientation() & ROT_INVALID) ? false : true;
352}
353
354void Transform::dump(const char* name) const
355{
356    type(); // updates the type
357
358    String8 flags, type;
359    const mat33& m(mMatrix);
360    uint32_t orient = mType >> 8;
361
362    if (orient&ROT_INVALID) {
363        flags.append("ROT_INVALID ");
364    } else {
365        if (orient&ROT_90) {
366            flags.append("ROT_90 ");
367        } else {
368            flags.append("ROT_0 ");
369        }
370        if (orient&FLIP_V)
371            flags.append("FLIP_V ");
372        if (orient&FLIP_H)
373            flags.append("FLIP_H ");
374    }
375
376    if (!(mType&(SCALE|ROTATE|TRANSLATE)))
377        type.append("IDENTITY ");
378    if (mType&SCALE)
379        type.append("SCALE ");
380    if (mType&ROTATE)
381        type.append("ROTATE ");
382    if (mType&TRANSLATE)
383        type.append("TRANSLATE ");
384
385    ALOGD("%s 0x%08x (%s, %s)", name, mType, flags.string(), type.string());
386    ALOGD("%.4f  %.4f  %.4f", m[0][0], m[1][0], m[2][0]);
387    ALOGD("%.4f  %.4f  %.4f", m[0][1], m[1][1], m[2][1]);
388    ALOGD("%.4f  %.4f  %.4f", m[0][2], m[1][2], m[2][2]);
389}
390
391// ---------------------------------------------------------------------------
392
393}; // namespace android
394