|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: Juha Kauppinen, Mika Hokkanen |
|
13 * |
|
14 * Description: Photo Browser |
|
15 * |
|
16 */ |
|
17 |
|
18 #include "CDrawFaceBrowsing.h" |
|
19 #include "TextureLoader.h" |
|
20 #include "DrawUtility.h" |
|
21 #include "ImagicConsts.h" |
|
22 |
|
23 #define IS_ALMOST_ZERO (0.001) |
|
24 |
|
25 |
|
26 CDrawFaceBrowsing::CDrawFaceBrowsing(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex): |
|
27 iContainer(aContainer)//, |
|
28 //iCurrentIndex(aCurrentIndex) |
|
29 { |
|
30 // No implementation required |
|
31 } |
|
32 |
|
33 CDrawFaceBrowsing::~CDrawFaceBrowsing() |
|
34 { |
|
35 iCoordinates.Close(); |
|
36 iFloatCoordinates.Close(); |
|
37 } |
|
38 |
|
39 CDrawFaceBrowsing* CDrawFaceBrowsing::NewLC(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex) |
|
40 { |
|
41 CDrawFaceBrowsing* self = new (ELeave) CDrawFaceBrowsing(aContainer,aCurrentIndex); |
|
42 CleanupStack::PushL(self); |
|
43 self->ConstructL(aContainer,aCurrentIndex); |
|
44 return self; |
|
45 } |
|
46 |
|
47 CDrawFaceBrowsing* CDrawFaceBrowsing::NewL(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex) |
|
48 { |
|
49 CDrawFaceBrowsing* self = CDrawFaceBrowsing::NewLC(aContainer,aCurrentIndex); |
|
50 CleanupStack::Pop(); // self; |
|
51 return self; |
|
52 } |
|
53 |
|
54 void CDrawFaceBrowsing::ConstructL(CImagicContainerBrowser* aContainer, TInt& aCurrentIndex) |
|
55 { |
|
56 //iContainer = aContainer; |
|
57 } |
|
58 |
|
59 void CDrawFaceBrowsing::KeyPressed() |
|
60 { |
|
61 iMenuAlpha = 1; |
|
62 } |
|
63 |
|
64 void CDrawFaceBrowsing::KeyReleased() |
|
65 { |
|
66 iMenuAlpha = 0.99; |
|
67 } |
|
68 |
|
69 void CDrawFaceBrowsing::KeyEvent() |
|
70 { |
|
71 //iMenuAlpha = 1; |
|
72 } |
|
73 |
|
74 void CDrawFaceBrowsing::GetFBZoomAndLocation(TReal& aDrawZoom, TReal& aInPictureX, TReal& aInPictureY) |
|
75 { |
|
76 aDrawZoom = iDrawZoom; |
|
77 aInPictureX = iInPictureX; |
|
78 aInPictureY = iInPictureY; |
|
79 } |
|
80 |
|
81 |
|
82 |
|
83 void CDrawFaceBrowsing::InitFaceBrowsing() |
|
84 { |
|
85 //iFBMovingSpeed = 1.4*iContainer->iTimeDiff; |
|
86 iFBMovingSpeed = 0.1; |
|
87 iFBRectCounter = 0; |
|
88 //iContainer->iDrawOneByOneTargetZoom=1; |
|
89 iDrawZoom=1; |
|
90 iDrawFBTargetZoom=1; |
|
91 iFBZoomingSpeed = 1.2*iContainer->iTimeDiff; |
|
92 iDrawX=0; |
|
93 iDrawY=0; |
|
94 iDrawTargetX=0; |
|
95 iDrawTargetY=0; |
|
96 //iInPictureX, iInPictureY |
|
97 |
|
98 } |
|
99 |
|
100 |
|
101 /*----------------------------------------------------------------------*/ |
|
102 // Draws FaceBrowser view |
|
103 // |
|
104 void CDrawFaceBrowsing::DrawFaceBrowsing(const TSize &aSize) |
|
105 { |
|
106 DP0_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceBrowsing")); |
|
107 |
|
108 CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex()); |
|
109 |
|
110 |
|
111 #ifdef SUPERZOOM |
|
112 if(imageData->iGridData.iGlSuperHQTextIndex == 0) |
|
113 { |
|
114 TRAPD(err, iContainer->iTextureLoader->LoadL(imageData, EFullSize)); |
|
115 } |
|
116 #endif |
|
117 |
|
118 //Calculate screen size |
|
119 iContainer->CalculateImageSize(iImageWidth, iImageHeight, (float)aSize.iWidth/(float)aSize.iHeight); |
|
120 |
|
121 if(imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle) |
|
122 iContainer->HandleRotation(imageData->iGridData.iRotationAngle, imageData->iGridData.iTargetRotationAngle); |
|
123 |
|
124 |
|
125 //Interpolate current screen size into the new one |
|
126 iContainer->Interpolate(iDrawWidth, iImageWidth, 0.75); |
|
127 iContainer->Interpolate(iDrawHeight, iImageHeight, 0.75); |
|
128 |
|
129 //Set orthigonal projection |
|
130 glLoadIdentity(); |
|
131 glOrthof(-iDrawWidth,iDrawWidth, -iDrawHeight, iDrawHeight, -1,1); |
|
132 |
|
133 //iContainer->Interpolate(iContainer->iDisplayRotation, iContainer->iDisplayRotationTarget, 0.2); |
|
134 float tmp = iContainer->GetDisplayRotAngle(); |
|
135 iContainer->Interpolate(tmp, iContainer->GetDisplayRotTargetAngle(), 0.2); |
|
136 iContainer->SetDisplayRotAngle(tmp); |
|
137 glRotatef(iContainer->GetDisplayRotAngle(), 0,0,1); |
|
138 |
|
139 |
|
140 //Handle coordinates-----------------------> |
|
141 if(iFaceNro < 0) |
|
142 iFaceNro = iCoordinates.Count()-1; |
|
143 if(iFaceNro >= iCoordinates.Count()) |
|
144 iFaceNro = 0; |
|
145 |
|
146 |
|
147 // Interpolate to new zoom value |
|
148 if( iContainer->iView->GetFaceBrowsingMode() != EFaceBrowsingShowRect ) |
|
149 iContainer->Interpolate(iDrawZoom, iDrawFBTargetZoom, iFBZoomingSpeed); |
|
150 |
|
151 //Convert coordinates from corner to center of screen |
|
152 if(iCoordinates.Count() >= 1) |
|
153 { |
|
154 //Convert integer coords to OpenGL float coords and fill array |
|
155 for(TInt i=0; iFloatCoordinates.Count() < iCoordinates.Count();i++) |
|
156 { |
|
157 iFloatCoordinates.Append(ConvertCoordsFromAlgo2OGl(iCoordIndex)); |
|
158 iCoordIndex++; |
|
159 } |
|
160 |
|
161 iDrawTargetX = iFloatCoordinates[iFaceNro].iX; |
|
162 iDrawTargetY = iFloatCoordinates[iFaceNro].iY; |
|
163 |
|
164 //Calculate face width and use that for zooming in factor |
|
165 float faceWidth = (iCoordinates[iFaceNro].iBr.iX - iCoordinates[iFaceNro].iTl.iX); |
|
166 float zoomFactor = faceWidth/20; |
|
167 |
|
168 if(iContainer->GetScreenOrientation()) |
|
169 iDrawFBTargetZoom = 4.6; |
|
170 else |
|
171 iDrawFBTargetZoom = 5.4; |
|
172 |
|
173 iDrawFBTargetZoom /= zoomFactor; |
|
174 if(iDrawFBTargetZoom <=1.6) |
|
175 iDrawFBTargetZoom = 1.6; |
|
176 |
|
177 } |
|
178 |
|
179 /*iContainer->iTouchMoveData.iX=0; |
|
180 iContainer->iTouchMoveData.iY=0;*///mika. to test doe this make anything at all???? |
|
181 |
|
182 |
|
183 // Calculate picture size |
|
184 iContainer->CalculateImageSize(iImageWidth, iImageHeight, imageData->GetAspectRatio()); |
|
185 |
|
186 iImageWidth*=iDrawFBTargetZoom; |
|
187 iImageHeight*=iDrawFBTargetZoom; |
|
188 |
|
189 //Calculate location/coordinates in screen |
|
190 iInPictureX = iDrawTargetX * iDrawFBTargetZoom; |
|
191 iInPictureY = iDrawTargetY * iDrawFBTargetZoom; |
|
192 |
|
193 iDrawTargetX = iInPictureX / iDrawFBTargetZoom; |
|
194 iDrawTargetY = iInPictureY / iDrawFBTargetZoom; |
|
195 |
|
196 if(!iContainer->GetScreenOrientation()) |
|
197 { |
|
198 float temp = iDrawTargetX; |
|
199 iDrawTargetX = iDrawTargetY; |
|
200 iDrawTargetY = -temp ; |
|
201 } |
|
202 |
|
203 // Move in picture------------------------> |
|
204 if( iContainer->iView->GetFaceBrowsingMode() != EFaceBrowsingShowRect ) |
|
205 { |
|
206 TInt imageRotation = 0 - (TReal)imageData->GetOrientation(); |
|
207 imageRotation%=360; |
|
208 |
|
209 if(imageRotation == 0) |
|
210 { |
|
211 iContainer->Interpolate(iDrawX,iDrawTargetX, iFBMovingSpeed); |
|
212 iContainer->Interpolate(iDrawY,iDrawTargetY, iFBMovingSpeed); |
|
213 } |
|
214 else if(imageRotation == -90) |
|
215 { |
|
216 iContainer->Interpolate(iDrawX,iDrawTargetY, iFBMovingSpeed); |
|
217 iContainer->Interpolate(iDrawY,-iDrawTargetX, iFBMovingSpeed); |
|
218 } |
|
219 else if(imageRotation == -180) |
|
220 { |
|
221 iContainer->Interpolate(iDrawX,-iDrawTargetX, iFBMovingSpeed); |
|
222 iContainer->Interpolate(iDrawY,-iDrawTargetY, iFBMovingSpeed); |
|
223 } |
|
224 else if(imageRotation == -270) |
|
225 { |
|
226 iContainer->Interpolate(iDrawX,-iDrawTargetY, iFBMovingSpeed); |
|
227 iContainer->Interpolate(iDrawY,iDrawTargetX, iFBMovingSpeed); |
|
228 } |
|
229 } |
|
230 |
|
231 iContainer->iCurrentBindedIndex = imageData->iGridData.BestImage(); |
|
232 glBindTexture( GL_TEXTURE_2D, iContainer->iCurrentBindedIndex); |
|
233 iContainer->SetMinMagFilterLinearDo(iContainer->iMinMagFilterSetting); |
|
234 |
|
235 // Calculate picture vertices |
|
236 GLfixed vertices[8]; |
|
237 iContainer->SetPictureVertices(imageData, vertices); |
|
238 glVertexPointer( 2, GL_FIXED, 0, vertices ); |
|
239 glColor4f(1,1,1, 1); |
|
240 glPushMatrix(); |
|
241 glScalef(iDrawZoom, iDrawZoom, iDrawZoom); |
|
242 glTranslatef(-iDrawX, iDrawY, 0); |
|
243 glRotatef(imageData->iGridData.iRotationAngle, 0,0,1); |
|
244 glDrawArrays(GL_TRIANGLE_STRIP,0,4); |
|
245 |
|
246 #ifdef RD_FACEFRAME |
|
247 if( iContainer->iView->GetFaceBrowsingMode() == EFaceBrowsingShowRect ) |
|
248 DrawFaceFrame(-1); |
|
249 |
|
250 if(ShowUtilities()) |
|
251 DrawFaceFrame(iFaceNro); |
|
252 |
|
253 //Draw face rects for ~ 0.5s time |
|
254 if(iFBRectCounter > 6) |
|
255 iContainer->iView->SetFaceBrowsingMode(EFaceBrowsing); |
|
256 else |
|
257 iFBRectCounter++; |
|
258 #endif |
|
259 |
|
260 glPopMatrix(); |
|
261 |
|
262 #ifdef RD_ZOOMICON |
|
263 if(ShowUtilities()) |
|
264 { |
|
265 //Draw moving direction arrays |
|
266 if(iFloatCoordinates.Count() >1) |
|
267 { |
|
268 TInt imageRotation = 0 - (TReal)imageData->GetOrientation(); |
|
269 |
|
270 if(iContainer->GetScreenOrientation()) |
|
271 { |
|
272 if(imageRotation == 0 || imageRotation == -180) |
|
273 { |
|
274 iContainer->iDrawUtility->DrawMovingArrow(ETrue, EFalse, iContainer->Size()); |
|
275 } |
|
276 else if(imageRotation == -90 || imageRotation == -270) |
|
277 { |
|
278 iContainer->iDrawUtility->DrawMovingArrow(EFalse, ETrue, iContainer->Size()); |
|
279 } |
|
280 } |
|
281 |
|
282 if(!iContainer->GetScreenOrientation()) |
|
283 { |
|
284 if(imageRotation == 0 || imageRotation == -180) |
|
285 { |
|
286 iContainer->iDrawUtility->DrawMovingArrow(EFalse, ETrue, iContainer->Size()); |
|
287 } |
|
288 else if(imageRotation == -90 || imageRotation == -270) |
|
289 { |
|
290 iContainer->iDrawUtility->DrawMovingArrow(EFalse, ETrue, iContainer->Size()); |
|
291 } |
|
292 } |
|
293 |
|
294 //iContainer->iDrawUtility->DrawMovingArrow(iContainer->GetScreenOrientation(), !iContainer->GetScreenOrientation(), iContainer->Size()); |
|
295 } |
|
296 |
|
297 |
|
298 iContainer->iDrawUtility->DrawZoomIcon( imageData, |
|
299 iContainer->Size(), |
|
300 -iDrawX, |
|
301 iDrawY, |
|
302 iDrawWidth/iImageWidth, |
|
303 iDrawHeight/iImageHeight, |
|
304 iContainer->iView->GetFaceBrowsingMode()==EFaceBrowsing); |
|
305 } |
|
306 |
|
307 #endif |
|
308 |
|
309 #if 0 |
|
310 if(iMenuAlpha < 1) |
|
311 { |
|
312 iMenuAlpha-=0.2; |
|
313 if(iMenuAlpha < 0) |
|
314 iMenuAlpha = 0; |
|
315 } |
|
316 |
|
317 iContainer->iDrawUtility->DrawIcon2(iContainer->Size(), iContainer->iLoadingTextureIndex, iMenuAlpha); |
|
318 #endif |
|
319 } |
|
320 |
|
321 |
|
322 TBool CDrawFaceBrowsing::ShowUtilities() |
|
323 { |
|
324 CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex()); |
|
325 TInt imageRotation = 0 - (TReal)imageData->GetOrientation(); |
|
326 |
|
327 if(imageRotation == -90 || imageRotation == -270) |
|
328 { |
|
329 if(Abs(iDrawX) != Abs(iDrawTargetY) || |
|
330 Abs(iDrawY) != Abs(iDrawTargetX) || |
|
331 iDrawZoom != iDrawFBTargetZoom || |
|
332 Abs(imageData->iGridData.iRotationAngle) != Abs(imageData->iGridData.iTargetRotationAngle) ) |
|
333 { |
|
334 return ETrue; |
|
335 } |
|
336 else |
|
337 { |
|
338 return EFalse; |
|
339 } |
|
340 } |
|
341 else |
|
342 { |
|
343 if(Abs(iDrawX) != Abs(iDrawTargetX) || |
|
344 Abs(iDrawY) != Abs(iDrawTargetY) || |
|
345 iDrawZoom != iDrawFBTargetZoom || |
|
346 Abs(imageData->iGridData.iRotationAngle) != Abs(imageData->iGridData.iTargetRotationAngle) ) |
|
347 { |
|
348 return ETrue; |
|
349 } |
|
350 else |
|
351 { |
|
352 return EFalse; |
|
353 } |
|
354 } |
|
355 } |
|
356 |
|
357 void CDrawFaceBrowsing::DrawFaceFrame(TInt aFace2bDrawn) |
|
358 { |
|
359 DP0_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame++")); |
|
360 |
|
361 |
|
362 CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex()); |
|
363 RArray<TRect> facecoords; |
|
364 facecoords.Reset(); |
|
365 |
|
366 //if(imageData->IsImageReady(ESize512x512)) |
|
367 { |
|
368 for(TInt i=0; i< iCoordinates.Count();i++) |
|
369 facecoords.Append(iCoordinates[i]); |
|
370 |
|
371 |
|
372 GLfixed vertices[8]; |
|
373 glPushMatrix(); |
|
374 glDisable(GL_TEXTURE_2D); |
|
375 glTranslatef(0, 0, 0.01f); |
|
376 glColor4f(0,0.7,0,1); |
|
377 glLineWidth(3.0f); |
|
378 glVertexPointer(2, GL_FIXED, 0, vertices); |
|
379 |
|
380 for(TInt i=0; i< facecoords.Count();i++) |
|
381 { |
|
382 GLfixed vx = (1<<15) * Abs(facecoords[i].iBr.iX + facecoords[i].iTl.iX); |
|
383 GLfixed vy = (1<<15) * Abs(facecoords[i].iBr.iY + facecoords[i].iTl.iY); |
|
384 GLfixed fW = (1<<16) * Abs(facecoords[i].iBr.iX - facecoords[i].iTl.iX); |
|
385 GLfixed fH = (1<<16) * Abs(facecoords[i].iBr.iY - facecoords[i].iTl.iY); |
|
386 |
|
387 DP5_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame face:%d (%d,%d), W/H=%d,%d"), i, vx, vy, fW, fH); |
|
388 |
|
389 vx /= 320; // Coords are given in 320x320 coords |
|
390 vy /= 320; // convert to OpenGL 1.0x1.0 coords |
|
391 fW /= 320; |
|
392 fH /= 320; |
|
393 |
|
394 float ar = imageData->GetAspectRatio(); |
|
395 |
|
396 if(ar > 1) |
|
397 { |
|
398 vx -= (1<<15); |
|
399 vy -= (0.5/ar)*(1<<16); |
|
400 } |
|
401 else |
|
402 { |
|
403 vx -= (0.5*ar)*(1<<16); |
|
404 vy -= (1<<15); |
|
405 } |
|
406 |
|
407 GLfixed x1 = vx-fW/2, x2 = vx+fW/2; |
|
408 GLfixed y1 = -vy-fH/2, y2 = -vy+fH/2; // -vy since y-coord in OpenGL is so |
|
409 |
|
410 DP5_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame face:%d (%d,%d), W/H=%d,%d"), i, vx, vy, fW, fH); |
|
411 DP4_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame xy12 (%d,%d), (%d,%d)"), x1, y1, x2, y2); |
|
412 |
|
413 vertices[0*2+0] = x1; vertices[0*2+1] = y1; |
|
414 vertices[1*2+0] = x2; vertices[1*2+1] = y1; |
|
415 vertices[2*2+0] = x2; vertices[2*2+1] = y2; |
|
416 vertices[3*2+0] = x1; vertices[3*2+1] = y2; |
|
417 |
|
418 if(i == aFace2bDrawn || aFace2bDrawn == -1) |
|
419 glDrawArrays(GL_LINE_LOOP,0,4); |
|
420 } |
|
421 |
|
422 glColor4f(1,1,1,1); |
|
423 glEnable(GL_TEXTURE_2D); |
|
424 glPopMatrix(); |
|
425 } |
|
426 |
|
427 DP0_IMAGIC(_L("CDrawFaceBrowsing::DrawFaceFrame--")); |
|
428 } |
|
429 |
|
430 |
|
431 TBool CDrawFaceBrowsing::IsDrawingNeededFaceBrowsing() |
|
432 { |
|
433 CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex()); |
|
434 |
|
435 if(Abs(iContainer->GetDisplayRotAngle() - iContainer->GetDisplayRotTargetAngle()) > 1) |
|
436 { |
|
437 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 6")); |
|
438 iContainer->SetMinMagFilterLinear(EFalse); |
|
439 return ETrue; |
|
440 } |
|
441 else if(iContainer->GetDisplayRotAngle() != iContainer->GetDisplayRotTargetAngle()) |
|
442 { |
|
443 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 6.1")); |
|
444 //iContainer->iDisplayRotation = iContainer->iDisplayRotationTarget; |
|
445 iContainer->SetDisplayRotAngle(iContainer->GetDisplayRotTargetAngle()); |
|
446 //iContainer->iDrawOneMoreTime = ETrue; |
|
447 iContainer->SetMinMagFilterLinear(ETrue); |
|
448 return ETrue; |
|
449 } |
|
450 |
|
451 if(Abs(imageData->iGridData.iRotationAngle - imageData->iGridData.iTargetRotationAngle) > 1) |
|
452 { |
|
453 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 7")); |
|
454 iContainer->SetMinMagFilterLinear(EFalse); |
|
455 return ETrue; |
|
456 } |
|
457 else if(imageData->iGridData.iRotationAngle != imageData->iGridData.iTargetRotationAngle) |
|
458 { |
|
459 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 7.1")); |
|
460 imageData->iGridData.iRotationAngle = imageData->iGridData.iTargetRotationAngle; |
|
461 iContainer->SetMinMagFilterLinear(ETrue); |
|
462 //iContainer->iDrawOneMoreTime = ETrue; |
|
463 return ETrue; |
|
464 } |
|
465 |
|
466 if(Abs(iDrawZoom - iDrawFBTargetZoom) > 0.01) |
|
467 { |
|
468 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 10")); |
|
469 iContainer->SetMinMagFilterLinear(EFalse); |
|
470 return ETrue; |
|
471 } |
|
472 else if(iDrawZoom != iDrawFBTargetZoom) |
|
473 { |
|
474 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 10.1")); |
|
475 iDrawZoom = iDrawFBTargetZoom; |
|
476 //iContainer->iDrawOneMoreTime = ETrue; |
|
477 iContainer->SetMinMagFilterLinear(ETrue); |
|
478 return ETrue; |
|
479 } |
|
480 |
|
481 |
|
482 TInt imageRotation = 0 - (TReal)imageData->GetOrientation(); |
|
483 |
|
484 if(imageRotation == -90 || imageRotation == -270) |
|
485 { |
|
486 if(Abs(Abs(iDrawX)-Abs(iDrawTargetY)) > 0.001) |
|
487 { |
|
488 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11")); |
|
489 iContainer->SetMinMagFilterLinear(EFalse); |
|
490 return ETrue; |
|
491 } |
|
492 else if(Abs(iDrawX) != Abs(iDrawTargetY)) |
|
493 { |
|
494 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11.1")); |
|
495 if(iDrawX < 0) |
|
496 iDrawX = 0-Abs(iDrawTargetY); |
|
497 else |
|
498 iDrawX = Abs(iDrawTargetY); |
|
499 //iContainer->iDrawOneMoreTime = ETrue; |
|
500 iContainer->SetMinMagFilterLinear(ETrue); |
|
501 return ETrue; |
|
502 } |
|
503 |
|
504 if(Abs(Abs(iDrawY)-Abs(iDrawTargetX)) > 0.001) |
|
505 { |
|
506 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12")); |
|
507 iContainer->SetMinMagFilterLinear(EFalse); |
|
508 return ETrue; |
|
509 } |
|
510 else if(Abs(iDrawY) != Abs(iDrawTargetX)) |
|
511 { |
|
512 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12.1")); |
|
513 if(iDrawY < 0) |
|
514 iDrawY = 0-Abs(iDrawTargetX); |
|
515 else |
|
516 iDrawY = Abs(iDrawTargetX); |
|
517 //iContainer->iDrawOneMoreTime = ETrue; |
|
518 iContainer->SetMinMagFilterLinear(ETrue); |
|
519 return ETrue; |
|
520 } |
|
521 } |
|
522 else |
|
523 { |
|
524 if(Abs(iDrawX-iDrawTargetX) > 0.001) |
|
525 { |
|
526 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11")); |
|
527 iContainer->SetMinMagFilterLinear(EFalse); |
|
528 return ETrue; |
|
529 } |
|
530 else if(iDrawX != iDrawTargetX) |
|
531 { |
|
532 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 11.1")); |
|
533 iDrawX = iDrawTargetX; |
|
534 //iContainer->iDrawOneMoreTime = ETrue; |
|
535 iContainer->SetMinMagFilterLinear(ETrue); |
|
536 return ETrue; |
|
537 } |
|
538 |
|
539 if(Abs(iDrawY-iDrawTargetY) > 0.001) |
|
540 { |
|
541 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12")); |
|
542 iContainer->SetMinMagFilterLinear(EFalse); |
|
543 return ETrue; |
|
544 } |
|
545 else if(iDrawY != iDrawTargetY) |
|
546 { |
|
547 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 12.1")); |
|
548 iDrawY = iDrawTargetY; |
|
549 //iContainer->iDrawOneMoreTime = ETrue; |
|
550 iContainer->SetMinMagFilterLinear(ETrue); |
|
551 return ETrue; |
|
552 } |
|
553 } |
|
554 |
|
555 /*if(iContainer->iDrawOneMoreTime) |
|
556 { |
|
557 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 14")); |
|
558 iContainer->iDrawOneMoreTime = EFalse; |
|
559 iContainer->SetMinMagFilterLinear(ETrue);//Draw one more time to change for Linear rendering mode |
|
560 return ETrue; |
|
561 }*/ |
|
562 |
|
563 if(!iContainer->iMagFilterLinear) |
|
564 { |
|
565 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 15")); |
|
566 iContainer->SetMinMagFilterLinear(ETrue); |
|
567 //iContainer->iDrawOneMoreTime = ETrue; |
|
568 } |
|
569 |
|
570 if(iContainer->iDrawNow) |
|
571 { |
|
572 DP0_IMAGIC(_L("CDrawFaceBrowsing::IsDrawingNeededOneByOne - 1")); |
|
573 /*if(iContainer->iMagGlassOn) |
|
574 { |
|
575 if(!iContainer->iTouchPointThreshold)//moved >2 pixel |
|
576 iContainer->SetMinMagFilterLinear(ETrue); |
|
577 else |
|
578 iContainer->SetMinMagFilterLinear(EFalse); |
|
579 } |
|
580 else*/ |
|
581 { |
|
582 iContainer->SetMinMagFilterLinear(ETrue); |
|
583 } |
|
584 |
|
585 //iDrawOneMoreTime = ETrue; |
|
586 iContainer->iDrawNow = EFalse; |
|
587 return ETrue; |
|
588 } |
|
589 |
|
590 return EFalse; |
|
591 } |
|
592 |
|
593 |
|
594 /*----------------------------------------------------------------------*/ |
|
595 // Calculate coords coords from alogorith to OpenGL -0.5 - +0.5 coords |
|
596 // |
|
597 FloatCoords CDrawFaceBrowsing::ConvertCoordsFromAlgo2OGl(const TInt aFaceIndex) |
|
598 { |
|
599 CImageData* imageData = iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex()); |
|
600 |
|
601 TInt pictureWidth, pictureHeigth; |
|
602 //We use always qvga image for Face detection |
|
603 pictureWidth=320; |
|
604 pictureHeigth=320; |
|
605 //landscape |
|
606 if(imageData->GetAspectRatio() > 1) |
|
607 pictureHeigth=pictureWidth/imageData->GetAspectRatio(); |
|
608 else//portrait |
|
609 pictureWidth=pictureHeigth*imageData->GetAspectRatio(); |
|
610 |
|
611 //calculate midpoint from face rect |
|
612 TInt xAvegCoord = (iCoordinates[aFaceIndex].iTl.iX + iCoordinates[aFaceIndex].iBr.iX)/2; |
|
613 TInt yAvegCoord = (iCoordinates[aFaceIndex].iTl.iY + iCoordinates[aFaceIndex].iBr.iY)/2; |
|
614 //and then convert coordinate zero point to center of screen |
|
615 xAvegCoord-=(pictureWidth/2); |
|
616 yAvegCoord-=(pictureHeigth/2); |
|
617 |
|
618 //Calculate coords coords from alogorith to OpenGL -0.5 - +0.5 coords and fill the array |
|
619 FloatCoords tmp; |
|
620 if(imageData->GetAspectRatio() > 1) |
|
621 { |
|
622 tmp.iX = (xAvegCoord * 0.5) / (pictureWidth/2); |
|
623 tmp.iY = (yAvegCoord * (0.5/imageData->GetAspectRatio())) / (pictureHeigth/2); |
|
624 } |
|
625 else//portrait |
|
626 { |
|
627 tmp.iX = (xAvegCoord * (0.5*imageData->GetAspectRatio())) / (pictureWidth/2); |
|
628 tmp.iY = (yAvegCoord * 0.5) / (pictureHeigth/2); |
|
629 } |
|
630 |
|
631 return tmp; |
|
632 } |
|
633 |
|
634 |
|
635 /*----------------------------------------------------------------------*/ |
|
636 // Draws one by one view |
|
637 // |
|
638 void CDrawFaceBrowsing::GetFaceCoordinatesL(TRect& aRect, TFileName& aFilename) |
|
639 { |
|
640 iContainer->iImagicAppUi->GetEngine()->GetFileNameL(iContainer->GetCurrentIndex(), ESize512x512, aFilename); |
|
641 |
|
642 if(iFaceNro < iCoordinates.Count() && iFaceNro >= 0) |
|
643 { |
|
644 aRect.iTl.iX = iCoordinates[iFaceNro].iTl.iX; |
|
645 aRect.iTl.iY = iCoordinates[iFaceNro].iTl.iY; |
|
646 aRect.iBr.iX = iCoordinates[iFaceNro].iBr.iX; |
|
647 aRect.iBr.iY = iCoordinates[iFaceNro].iBr.iY; |
|
648 } |
|
649 } |
|
650 |
|
651 /*----------------------------------------------------------------------*/ |
|
652 // Draws one by one view |
|
653 // |
|
654 TInt CDrawFaceBrowsing::GetNumberOfFaces() |
|
655 { |
|
656 return iCoordinates.Count(); |
|
657 } |
|
658 |
|
659 /*----------------------------------------------------------------------*/ |
|
660 // Draws one by one view |
|
661 // |
|
662 void CDrawFaceBrowsing::SetCurrentFaceNro(TInt aNro) |
|
663 { |
|
664 iFaceNro = aNro; |
|
665 |
|
666 if(iFaceNro < 0) |
|
667 iFaceNro = 0; |
|
668 if(iFaceNro >= iCoordinates.Count()) |
|
669 iFaceNro = 0; |
|
670 } |
|
671 |
|
672 /*----------------------------------------------------------------------*/ |
|
673 // Gets current face nro |
|
674 // |
|
675 TInt CDrawFaceBrowsing::GetCurrentFaceNro() |
|
676 { |
|
677 return iFaceNro; |
|
678 } |
|
679 |
|
680 void CDrawFaceBrowsing::SetFaceCoords(RArray<TRect>& aCoordinates) |
|
681 { |
|
682 ClearFaceArray(); |
|
683 |
|
684 for(TInt i = 0; i < aCoordinates.Count(); i++) |
|
685 { |
|
686 iCoordinates.Append(aCoordinates[i]); |
|
687 } |
|
688 |
|
689 iDrawFBTargetZoom = 0; |
|
690 iFaceNro = 0; |
|
691 } |
|
692 |
|
693 void CDrawFaceBrowsing::ClearFaceArray() |
|
694 { |
|
695 //iCoordinates.Reset(); |
|
696 TInt tmp = iCoordinates.Count(); |
|
697 //delete array if we had old data there |
|
698 for(TInt i = 0; i < tmp; i++) |
|
699 { |
|
700 iCoordinates.Remove(0); |
|
701 } |
|
702 |
|
703 tmp = iFloatCoordinates.Count(); |
|
704 for(TInt i = 0; i < tmp; i++) |
|
705 { |
|
706 iFloatCoordinates.Remove(0); |
|
707 } |
|
708 iCoordIndex=0; |
|
709 } |
|
710 |
|
711 TInt CDrawFaceBrowsing::GetFaceCount() |
|
712 { |
|
713 return iCoordinates.Count(); |
|
714 } |
|
715 |
|
716 void CDrawFaceBrowsing::IncFaceNumber() |
|
717 { |
|
718 iFaceNro++; |
|
719 } |
|
720 |
|
721 void CDrawFaceBrowsing::DecFaceNumber() |
|
722 { |
|
723 iFaceNro--; |
|
724 } |