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> 32 static inline T min(T a, T b) { 33 return a<b ? a : b; 34 } 35 template <typename T> 36 static inline T min(T a, T b, T c) { 37 return min(a, min(b, c)); 38 } 39 template <typename T> 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> 45 static inline T max(T a, T b) { 46 return a>b ? a : b; 47 } 48 template <typename T> 49 static inline T max(T a, T b, T c) { 50 return max(a, max(b, c)); 51 } 52 template <typename T> 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 59 void swap(T& a, T& b) { 60 T t(a); 61 a = b; 62 b = t; 63 } 64 65 // --------------------------------------------------------------------------- 66 67 Transform::Transform() { 68 reset(); 69 } 70 71 Transform::Transform(const Transform& other) 72 : mMatrix(other.mMatrix), mType(other.mType) { 73 } 74 75 Transform::Transform(uint32_t orientation) { 76 set(orientation, 0, 0); 77 } 78 79 Transform::~Transform() { 80 } 81 82 static const float EPSILON = 0.0f; 83 84 bool Transform::isZero(float f) { 85 return fabs(f) <= EPSILON; 86 } 87 88 bool Transform::absIsOne(float f) { 89 return isZero(fabs(f) - 1.0f); 90 } 91 92 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 121 float const* Transform::operator [] (int i) const { 122 return mMatrix[i].v; 123 } 124 125 bool Transform::transformed() const { 126 return type() > TRANSLATE; 127 } 128 129 int Transform::tx() const { 130 return floorf(mMatrix[2][0] + 0.5f); 131 } 132 133 int Transform::ty() const { 134 return floorf(mMatrix[2][1] + 0.5f); 135 } 136 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 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 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 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 211 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 219 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 228 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 237 Rect Transform::makeBounds(int w, int h) const 238 { 239 return transform( Rect(w, h) ); 240 } 241 242 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 263 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 282 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 334 uint32_t Transform::getType() const { 335 return type() & 0xFF; 336 } 337 338 uint32_t Transform::getOrientation() const 339 { 340 return (type() >> 8) & 0xFF; 341 } 342 343 bool Transform::preserveRects() const 344 { 345 return (type() & ROT_INVALID) ? false : true; 346 } 347 348 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
