diff -r f5050f1da672 -r 04becd199f91 javauis/amms_akn/module/src/ammsutil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javauis/amms_akn/module/src/ammsutil.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,366 @@ +/* +* Copyright (c) 2005-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Static general reusable methods. +* +*/ + + +// INCLUDE FILES +#include +#include "ammsutil.h" +#include +#include +#include "cammscontrol.h" + +// CONSTANTS +namespace +{ +const TInt KAMMSStraightAngle = 180; + +// Set a value to 0 if its absolute value is less than this. +const TReal KAMMSDiscreteErrorConstant = 0.00000001; +} + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CAMMSControlGroup::FindControl +// Finds the control of a corresponding name. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +CMMAControl* AMMSUtil::FindControl(CMMAPlayer* aPlayer, + const TDesC& aControlName, + TAMMSControlTypes aControlType) +{ + TInt controlCount = aPlayer->ControlCount(); + TInt index = 0; + + // if control is not found NULL will be returned + CMMAControl* control = NULL; + + // go through all controls + while (index < controlCount) + { + CMMAControl* tmp = aPlayer->Control(index); + + // if the name of the Control matches the name used in finding + if (tmp->ClassName() == aControlName) + { + + // a base Control can be accepted always, it can not be derived + if (aControlType == EAMMSBaseControl) + { + // found correct control + control = tmp; + + // set index to stop while loop + index = controlCount; + } + + // in case the Control is not a base Control, check AMMS subtype + else + { + if (aControlType == ((CAMMSControl*)tmp)->iControlType) + { + // found correct (derived) control + control = tmp; + + // set index to stop while loop + index = controlCount; + } + else + { + // move to next control + index++; + } + } + } + + // Control name was not the one used in finding + else + { + // move to next control + index++; + } + } + return control; +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::FromSphericalToCartesianL +// Converts vector from spherical to cartesian. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void AMMSUtil::FromSphericalToCartesianL( + TInt aSphericalVector[ KAMMSVectorComponents ], + TInt aCartesianVector[ KAMMSVectorComponents ]) +{ + // convert to radians + TReal elevation = aSphericalVector[ EElevation ] * + (KPi / KAMMSStraightAngle); + TReal azimuth = aSphericalVector[ EAzimuth ] * + (KPi / KAMMSStraightAngle); + TReal radius = aSphericalVector[ ERadius ]; + + TReal elevationSin; + TReal elevationCos; + User::LeaveIfError(Math::Sin(elevationSin, elevation)); + User::LeaveIfError(Math::Cos(elevationCos, elevation)); + + TReal cartesian[ KAMMSVectorComponents ]; + + cartesian[ EComponentY ] = elevationSin * radius; + TReal distXZ = elevationCos * radius; // distance in x-z plane + + TReal azimuthSin; + TReal azimuthCos; + User::LeaveIfError(Math::Sin(azimuthSin, azimuth)); + User::LeaveIfError(Math::Cos(azimuthCos, azimuth)); + + // azimuth of 0 degrees points to negative z axis + cartesian[ EComponentZ ] = -azimuthCos * distXZ; + cartesian[ EComponentX ] = azimuthSin * distXZ; + + // round real values and convert them to integers + RoundVectorL(cartesian, aCartesianVector); +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::RotateVectorL +// Rotates a vector round the given axis. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void AMMSUtil::RotateVectorL( + TReal aVector[ KAMMSVectorComponents ], + TReal aAxisVector[ KAMMSVectorComponents ], + TInt aAngle, + TReal aRotatedVector[ KAMMSVectorComponents ]) +{ + // calculate the length of the axis vector + TReal lengthSquare = aAxisVector[ EComponentX ] * + aAxisVector[ EComponentX ] + aAxisVector[ EComponentY ] * + aAxisVector[ EComponentY ] + aAxisVector[ EComponentZ ] * + aAxisVector[ EComponentZ ]; + + TReal length; + User::LeaveIfError(Math::Sqrt(length, lengthSquare)); + + // check that the vector is long enough + __ASSERT_DEBUG(length > 0, User::Invariant()); + + // normalize the axis vector + TReal x = aAxisVector[ EComponentX ] / length; + TReal y = aAxisVector[ EComponentY ] / length; + TReal z = aAxisVector[ EComponentZ ] / length; + + // calculate sine and cosine values + TReal angleRad = aAngle / 180.0 * KPi; + TReal c; + User::LeaveIfError(Math::Cos(c, angleRad)); + TReal s; + User::LeaveIfError(Math::Sin(s, angleRad)); + + // calculate some help variables + TReal t = 1 - c; + TReal txy = t * x * y; + TReal txz = t * x * z; + TReal tyz = t * y * z; + TReal sz = s * z; + TReal sy = s * y; + TReal sx = s * x; + TReal x2 = aVector[ EComponentX ]; + TReal y2 = aVector[ EComponentY ]; + TReal z2 = aVector[ EComponentZ ]; + + // calculate new x value + aRotatedVector[ EComponentX ] = (t * x * x + c) * x2 + + (txy - sz) * y2 + (txz + sy) * z2; + + // calculate new y value + aRotatedVector[ EComponentY ] = (txy + sz) * x2 + + (t * y * y + c) * y2 + (tyz - sx) * z2; + + // calculate new z value + aRotatedVector[ EComponentZ ] = (txz - sy) * x2 + + (tyz + sx) * y2 + (t * z * z + c) * z2; + + // Remove error of discrete values. + for (TInt i = 0; i < KAMMSVectorComponents; i++) + { + if (Abs(aRotatedVector[ i ]) < KAMMSDiscreteErrorConstant) // CSI: 2 Wrong index means implementation error # + { + aRotatedVector[ i ] = 0; // CSI: 2 Wrong index means implementation error # + } + } +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::RoundVectorL +// Rounds vector components. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void AMMSUtil::RoundVectorL( + TReal aVector[ KAMMSVectorComponents ], + TInt aRoundedVector[ KAMMSVectorComponents ]) +{ + for (TInt i = 0; i < KAMMSVectorComponents; i++) + { + TReal roundedValue; + User::LeaveIfError(Math::Round(roundedValue, + (TReal)aVector[ i ], 0)); // CSI: 2 Wrong index means implementation error # + + aRoundedVector[ i ] = (TInt)roundedValue; // CSI: 2 Wrong index means implementation error # + } +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::MultiplyVector +// Multiplies a vector by a scalar. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void AMMSUtil::MultiplyVector( + TReal aVector[ KAMMSVectorComponents ], + TReal aMultiplier) +{ + for (TInt i = 0; i < KAMMSVectorComponents; i++) + { + aVector[ i ] *= aMultiplier; // CSI: 2 Wrong index means implementation error # + } +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::CrossProduct +// Calculates vector cross product. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void AMMSUtil::CrossProduct( + TReal aA[ KAMMSVectorComponents ], + TReal aB[ KAMMSVectorComponents ], + TReal aResultVector[ KAMMSVectorComponents ]) +{ + // This function can handle only vectors with 3 components + + // Calculate the cross product. + aResultVector[ EComponentX ] = -aA[ EComponentZ ] * aB[ EComponentY ] + + aA[ EComponentY ] * aB[ EComponentZ ]; + + aResultVector[ EComponentY ] = aA[ EComponentZ ] * aB[ EComponentX ] - + aA[ EComponentX ] * aB[ EComponentZ ]; + + aResultVector[ EComponentZ ] = -aA[ EComponentY ] * aB[ EComponentX ] + + aA[ EComponentX ] * aB[ EComponentY ]; +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::VectorLengthL +// Calculates the length of the given vector. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +TReal AMMSUtil::VectorLengthL( + TReal aVector[ KAMMSVectorComponents ]) +{ + TReal squareLength = 0; + + for (TInt i = 0; i < KAMMSVectorComponents; i++) + { + squareLength += aVector[ i ] * aVector[ i ]; + } + + TReal length; + User::LeaveIfError(Math::Sqrt(length, squareLength)); + + return length; +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::ConvertToUnitVectorL +// Converts the given vector to unit vector. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void AMMSUtil::ConvertToUnitVectorL( + TReal aVector[ KAMMSVectorComponents ]) +{ + TReal length = VectorLengthL(aVector); + + for (TInt i = 0; i < KAMMSVectorComponents; i++) + { + aVector[ i ] /= length; // CSI: 2 Wrong index means implementation error # + } +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::AreVectorsSimilar +// Checks whether two vectors are similar enough. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +TBool AMMSUtil::AreVectorsSimilar( + TReal aA[ KAMMSVectorComponents ], + TInt aB[ KAMMSVectorComponents ], + TInt aMaxComponentErrorPercentage) +{ + TReal maxRelativeError = aMaxComponentErrorPercentage / 100.0; // CSI: 47 Value 100 means 100% # + + for (TInt i = 0; i < KAMMSVectorComponents; i++) + { + TReal maxError = + Max(Abs(aA[ i ]), Abs(aB[ i ])) * maxRelativeError; // CSI: 2 Wrong index means implementation error # + + if (Abs(aA[ i ] - aB[ i ]) > maxError) // CSI: 2 Wrong index means implementation error # + { + return EFalse; + } + } + + // Vectors were similar enough. + return ETrue; +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::MaxVectorComponent +// Returns the maximum component in the given vector. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +TReal AMMSUtil::MaxVectorComponent( + TReal aVector[ KAMMSVectorComponents ]) +{ + TReal maxValue = aVector[ 0 ]; + + for (TInt i = 1; i < KAMMSVectorComponents; i++) + { + maxValue = Max(maxValue, aVector[ i ]); // CSI: 2 Wrong index means implementation error # + } + + return maxValue; +} + +// ----------------------------------------------------------------------------- +// AMMSUtil::MinVectorComponent +// Returns the minimum component in the given vector. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +TReal AMMSUtil::MinVectorComponent( + TReal aVector[ KAMMSVectorComponents ]) +{ + TReal minValue = aVector[ 0 ]; + + for (TInt i = 1; i < KAMMSVectorComponents; i++) + { + minValue = Min(minValue, aVector[ i ]); // CSI: 2 Wrong index means implementation error # + } + + return minValue; +} + +// End of File