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     }