/*
* 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 <e32math.h>
#include "ammsutil.h"
#include <cmmaplayer.h>
#include <cmmacontrol.h>
#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