Transform.cpp revision 4c05dd175ee3bd5119eecf368742b6510a8cfa6c
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 86float const* Transform::operator [] (int i) const { 87 return mMatrix[i].v; 88} 89 90bool Transform::transformed() const { 91 return type() > TRANSLATE; 92} 93 94float Transform::tx() const { 95 return mMatrix[2][0]; 96} 97 98float Transform::ty() const { 99 return mMatrix[2][1]; 100} 101 102void Transform::reset() { 103 mType = IDENTITY; 104 for(int i=0 ; i<3 ; i++) { 105 vec3& v(mMatrix[i]); 106 for (int j=0 ; j<3 ; j++) 107 v[j] = ((i==j) ? 1.0f : 0.0f); 108 } 109} 110 111void Transform::set(float tx, float ty) 112{ 113 mMatrix[2][0] = tx; 114 mMatrix[2][1] = ty; 115 mMatrix[2][2] = 1.0f; 116 117 if (isZero(tx) && isZero(ty)) { 118 mType &= ~TRANSLATE; 119 } else { 120 mType |= TRANSLATE; 121 } 122} 123 124void Transform::set(float a, float b, float c, float d) 125{ 126 mat33& M(mMatrix); 127 M[0][0] = a; M[1][0] = b; 128 M[0][1] = c; M[1][1] = d; 129 M[0][2] = 0; M[1][2] = 0; 130 mType = UNKNOWN_TYPE; 131} 132 133status_t Transform::set(uint32_t flags, float w, float h) 134{ 135 if (flags & ROT_INVALID) { 136 // that's not allowed! 137 reset(); 138 return BAD_VALUE; 139 } 140 141 Transform H, V, R; 142 if (flags & ROT_90) { 143 // w & h are inverted when rotating by 90 degrees 144 swap(w, h); 145 } 146 147 if (flags & FLIP_H) { 148 H.mType = (FLIP_H << 8) | SCALE; 149 H.mType |= isZero(w) ? IDENTITY : TRANSLATE; 150 mat33& M(H.mMatrix); 151 M[0][0] = -1; 152 M[2][0] = w; 153 } 154 155 if (flags & FLIP_V) { 156 V.mType = (FLIP_V << 8) | SCALE; 157 V.mType |= isZero(h) ? IDENTITY : TRANSLATE; 158 mat33& M(V.mMatrix); 159 M[1][1] = -1; 160 M[2][1] = h; 161 } 162 163 if (flags & ROT_90) { 164 const float original_w = h; 165 R.mType = (ROT_90 << 8) | ROTATE; 166 R.mType |= isZero(original_w) ? IDENTITY : TRANSLATE; 167 mat33& M(R.mMatrix); 168 M[0][0] = 0; M[1][0] =-1; M[2][0] = original_w; 169 M[0][1] = 1; M[1][1] = 0; 170 } 171 172 *this = (R*(H*V)); 173 return NO_ERROR; 174} 175 176Transform::vec2 Transform::transform(const vec2& v) const { 177 vec2 r; 178 const mat33& M(mMatrix); 179 r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]; 180 r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]; 181 return r; 182} 183 184Transform::vec3 Transform::transform(const vec3& v) const { 185 vec3 r; 186 const mat33& M(mMatrix); 187 r[0] = M[0][0]*v[0] + M[1][0]*v[1] + M[2][0]*v[2]; 188 r[1] = M[0][1]*v[0] + M[1][1]*v[1] + M[2][1]*v[2]; 189 r[2] = M[0][2]*v[0] + M[1][2]*v[1] + M[2][2]*v[2]; 190 return r; 191} 192 193void Transform::transform(float* point, int x, int y) const 194{ 195 vec2 v(x, y); 196 v = transform(v); 197 point[0] = v[0]; 198 point[1] = v[1]; 199} 200 201Rect Transform::makeBounds(int w, int h) const 202{ 203 return transform( Rect(w, h) ); 204} 205 206Rect Transform::transform(const Rect& bounds) const 207{ 208 Rect r; 209 vec2 lt( bounds.left, bounds.top ); 210 vec2 rt( bounds.right, bounds.top ); 211 vec2 lb( bounds.left, bounds.bottom ); 212 vec2 rb( bounds.right, bounds.bottom ); 213 214 lt = transform(lt); 215 rt = transform(rt); 216 lb = transform(lb); 217 rb = transform(rb); 218 219 r.left = floorf(min(lt[0], rt[0], lb[0], rb[0]) + 0.5f); 220 r.top = floorf(min(lt[1], rt[1], lb[1], rb[1]) + 0.5f); 221 r.right = floorf(max(lt[0], rt[0], lb[0], rb[0]) + 0.5f); 222 r.bottom = floorf(max(lt[1], rt[1], lb[1], rb[1]) + 0.5f); 223 224 return r; 225} 226 227Region Transform::transform(const Region& reg) const 228{ 229 Region out; 230 if (CC_UNLIKELY(transformed())) { 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 301uint32_t Transform::getType() const { 302 return type() & 0xFF; 303} 304 305uint32_t Transform::getOrientation() const 306{ 307 return (type() >> 8) & 0xFF; 308} 309 310bool Transform::preserveRects() const 311{ 312 return (getOrientation() & ROT_INVALID) ? false : true; 313} 314 315void Transform::dump(const char* name) const 316{ 317 type(); // updates the type 318 319 String8 flags, type; 320 const mat33& m(mMatrix); 321 uint32_t orient = mType >> 8; 322 323 if (orient&ROT_INVALID) { 324 flags.append("ROT_INVALID "); 325 } else { 326 if (orient&ROT_90) { 327 flags.append("ROT_90 "); 328 } else { 329 flags.append("ROT_0 "); 330 } 331 if (orient&FLIP_V) 332 flags.append("FLIP_V "); 333 if (orient&FLIP_H) 334 flags.append("FLIP_H "); 335 } 336 337 if (!(mType&(SCALE|ROTATE|TRANSLATE))) 338 type.append("IDENTITY "); 339 if (mType&SCALE) 340 type.append("SCALE "); 341 if (mType&ROTATE) 342 type.append("ROTATE "); 343 if (mType&TRANSLATE) 344 type.append("TRANSLATE "); 345 346 ALOGD("%s 0x%08x (%s, %s)", name, mType, flags.string(), type.string()); 347 ALOGD("%.4f %.4f %.4f", m[0][0], m[1][0], m[2][0]); 348 ALOGD("%.4f %.4f %.4f", m[0][1], m[1][1], m[2][1]); 349 ALOGD("%.4f %.4f %.4f", m[0][2], m[1][2], m[2][2]); 350} 351 352// --------------------------------------------------------------------------- 353 354}; // namespace android 355