QPointF utmToLatLong(const QPointF &utm, char latZ, int lonZ)
{
qreal easting = utm.x();
qreal northing = utm.y();
qreal UTM_F0 = 0.9996;
qreal a = 6378137.000;
qreal eSquared = ((a * a) - (6356752.3141 * 6356752.3141)) / (a * a);
qreal ePrimeSquared = eSquared / (1.0 - eSquared);
qreal e1 = (1 - qSqrt(1 - eSquared)) / (1 + qSqrt(1 - eSquared));
qreal x = easting - 500000.0;
qreal y = northing;
int zoneNumber = lonZ;
char zoneLetter = latZ;
qreal longitudeOrigin = (zoneNumber - 1.0) * 6.0 - 180.0 + 3.0;
// Correct y for southern hemisphere
if ((zoneLetter - 'N') < 0) {
y -= 10000000.0;
}
qreal m = y / UTM_F0;
qreal mu = m / (a * (1.0 - eSquared / 4.0 - 3.0 * eSquared * eSquared / 64.0 - 5.0 * qPow(eSquared, 3.0) / 256.0));
qreal phi1Rad = mu + (3.0 * e1 / 2.0 - 27.0 * qPow(e1, 3.0) / 32.0)
* qSin(2.0 * mu)
+ (21.0 * e1 * e1 / 16.0 - 55.0 * qPow(e1, 4.0) / 32.0)
* qSin(4.0 * mu) + (151.0 * qPow(e1, 3.0) / 96.0)
* qSin(6.0 * mu);
qreal n = a / qSqrt(1.0 - eSquared * qSin(phi1Rad) * qSin(phi1Rad));
qreal t = qTan(phi1Rad) * qTan(phi1Rad);
qreal c = ePrimeSquared * qCos(phi1Rad) * qCos(phi1Rad);
qreal r = a * (1.0 - eSquared) / qPow(1.0 - eSquared * qSin(phi1Rad) * qSin(phi1Rad), 1.5);
qreal d = x / (n * UTM_F0);
qreal latitude = (phi1Rad - (n * qTan(phi1Rad) / r)
* (d * d / 2.0
- (5.0 + (3.0 * t) + (10.0 * c) - (4.0 * c * c) - (9.0 * ePrimeSquared))
* qPow(d, 4.0) / 24.0 + (61.0 + (90.0 * t) + (298.0 * c)
+ (45.0 * t * t) - (252.0 * ePrimeSquared) - (3.0 * c * c))
* qPow(d, 6.0) / 720.0))
* (180.0 / M_PI);
qreal longitude = longitudeOrigin
+ ((d - (1.0 + 2.0 * t + c) * qPow(d, 3.0) / 6.0 + (5.0
- (2.0 * c) + (28.0 * t) - (3.0 * c * c)
+ (8.0 * ePrimeSquared) + (24.0 * t * t))
* qPow(d, 5.0) / 120.0) / qCos(phi1Rad))
* (180.0 / M_PI);
return QPointF(latitude, longitude);
}
void VerticalPerspectiveProjectionPrivate::calculateConstants(qreal radius) const
{
if (radius == m_previousRadius) return;
m_previousRadius = radius;
m_P = 1.5 + 3 * 1000 * 0.4 / radius / qTan(0.5 * 110 * DEG2RAD);
m_altitudeToPixel = radius / (EARTH_RADIUS * qSqrt((m_P-1)/(m_P+1)));
m_perspectiveRadius = radius / qSqrt((m_P-1)/(m_P+1));
m_pPfactor = (m_P+1)/(m_perspectiveRadius*m_perspectiveRadius*(m_P-1));
}
void MainWindow:: equals()
{
sNum = value.toDouble();
if (addBool){
total = QString::number(fNum+sNum);
label -> setText(total);
}
if (subtractBool){
total = QString::number(fNum-sNum);
label -> setText(total);
}
if (multiplyBool){
total = QString::number(fNum*sNum);
label -> setText(total);
}
if(divideBool){
total = QString::number(fNum/sNum);
label -> setText(total);
}
if(sinBool){
total = QString::number(qSin(fNum));
label -> setText(total);
}
if(cosBool){
total = QString::number(qCos(fNum));
label -> setText(total);
}
if(tanBool){
total = QString::number(qTan(fNum));
label -> setText(total);
}
if(sqrtBool){
total = QString::number(qSqrt(fNum));
label -> setText(total);
}
if(powBool){
total = QString::number(qPow(fNum,2));
label -> setText(total);
}
if(cubicBool){
total = QString::number(qPow(fNum,3));
label -> setText(total);
}
if(expBool){
total = QString::number(qExp(fNum));
label -> setText(total);
}
if(lnBool){
total = QString::number(qLn(fNum));
label -> setText(total);
}
fNum = 0;
sNum = 0;
}
void PerspectiveProjection::setup(QVector3D position, QVector3D view, QVector3D up, qreal aspectRatio) {
qreal hfov = qTan(m_fov * 0.5);
m_origin = position;
m_xVector = QVector3D::normal(up, view) * (hfov * aspectRatio * 2.0);
m_yVector = -up.normalized() * (hfov * 2.0);
m_corner = view.normalized() - (m_xVector * 0.5) - (m_yVector * 0.5);
}
Rpn::Operand Tangent::calculate(FunctionCalculator *calculator, QList<Rpn::Operand> actualArguments)
{
Q_UNUSED(calculator);
Rpn::Operand result;
result.type = Rpn::OperandNumber;
result.value = qTan(actualArguments.at(0).value.value<Number>());
return result;
}
float Material::cookTorrance(const QVector3D &v, const QVector3D &n, const QVector3D &L, float F, float m)
{
QVector3D vL = v + L;
QVector3D h = vL / vL.length();
float nh = QVector3D::dotProduct(n, h);
float nv = QVector3D::dotProduct(n, v);
float vh = QVector3D::dotProduct(v, h);
float nL = QVector3D::dotProduct(n, L);
float m2 = m * m;
float alpha = qMin(0.999, qAcos(nh));
float G = qMin(1.0f, qMin(2.0f * nh * nv / vh, 2.0f * nh * nL / vh));
float D = qExp(-qPow(qTan(alpha), 2.0f) / m2) / (m2 * qPow(qCos(alpha), 4.0f));
return qMin(24.0f, F * G * D / (4.0f * float(M_PI) * nL * nv));
}
void USBManager::getLPCoefficientsButterworth2Pole(const int pSamplerate, const double pCutoff, double* const pAx, double* const pBy)
{
const double PI = 3.1415926535897932385;
const double sqrt2 = 1.4142135623730950488;
double QcRaw = (2 * PI * CUT_OFF_LOW) / pSamplerate; // Find cutoff frequency in [0..PI]
double QcWarp = qTan(CUT_OFF_LOW); // Warp cutoff frequency
double gain = 1 / (1+sqrt2/QcWarp + 2/(QcWarp*QcWarp));
pBy[2] = (1 - sqrt2/QcWarp + 2/(QcWarp*QcWarp)) * gain;
pBy[1] = (2 - 2 * 2/(QcWarp*QcWarp)) * gain;
pBy[0] = 1;
pAx[0] = 1 * gain;
pAx[1] = 2 * gain;
pAx[2] = 1 * gain;
}
void WTFWidget::drawInnerArrow(QPainter& painter) {
if(_innerPercent == 0) return;
QRect rect = this->contentsRect();
QPoint center = rect.center();
painter.save();
painter.translate(center);
painter.rotate(90 * _innerPercent);
QColor arrowColor = QColor::fromRgb(0xff,0xff,0xff,0xff * _innerPercent);
QPen pen = QPen(arrowColor);
pen.setWidth(2);
painter.setPen(pen);
int left = - CIRCLE_INNER_RADIUS;
int top = - CIRCLE_INNER_RADIUS;
QRect arcRect = QRect(left,top,CIRCLE_INNER_RADIUS * 2,
CIRCLE_INNER_RADIUS * 2);
painter.drawArc(arcRect,90 * 16,270 * 16);
// start draw arrow
qreal arrowBorderLen = 8;
QPainterPath path;
QPoint topPoint(0,
- CIRCLE_INNER_RADIUS - arrowBorderLen/2);
path.moveTo(topPoint);
qreal distance = (arrowBorderLen / 2) / qTan(qDegreesToRadians((double)30));
QPoint rightPoint(distance,-CIRCLE_INNER_RADIUS);
path.lineTo(rightPoint);
QPoint bottomPoint(0,
- CIRCLE_INNER_RADIUS + arrowBorderLen/2);
path.lineTo(bottomPoint);
path.closeSubpath();
painter.fillPath(path,QBrush(arrowColor));
painter.translate(-center.x(),-center.y());
painter.restore();
}
void QSvgAnimateTransform::resolveMatrix(const QSvgNode *node)
{
static const qreal deg2rad = qreal(0.017453292519943295769);
qreal totalTimeElapsed = node->document()->currentElapsed();
if (totalTimeElapsed < m_from || m_finished)
return;
qreal animationFrame = 0;
if (m_totalRunningTime != 0) {
animationFrame = (totalTimeElapsed - m_from) / m_totalRunningTime;
if (m_repeatCount >= 0 && m_repeatCount < animationFrame) {
m_finished = true;
animationFrame = m_repeatCount;
}
}
qreal percentOfAnimation = animationFrame;
if (percentOfAnimation > 1) {
percentOfAnimation -= ((int)percentOfAnimation);
}
qreal currentPosition = percentOfAnimation * (m_count - 1);
int startElem = qFloor(currentPosition);
int endElem = qCeil(currentPosition);
switch(m_type)
{
case Translate: {
startElem *= 3;
endElem *= 3;
qreal from1, from2;
qreal to1, to2;
from1 = m_args[startElem++];
from2 = m_args[startElem++];
to1 = m_args[endElem++];
to2 = m_args[endElem++];
qreal transXDiff = (to1-from1) * percentOfAnimation;
qreal transX = from1 + transXDiff;
qreal transYDiff = (to2-from2) * percentOfAnimation;
qreal transY = from2 + transYDiff;
m_transform = QTransform();
m_transform.translate(transX, transY);
break;
}
case Scale: {
startElem *= 3;
endElem *= 3;
qreal from1, from2;
qreal to1, to2;
from1 = m_args[startElem++];
from2 = m_args[startElem++];
to1 = m_args[endElem++];
to2 = m_args[endElem++];
qreal transXDiff = (to1-from1) * percentOfAnimation;
qreal transX = from1 + transXDiff;
qreal transYDiff = (to2-from2) * percentOfAnimation;
qreal transY = from2 + transYDiff;
if (transY == 0)
transY = transX;
m_transform = QTransform();
m_transform.scale(transX, transY);
break;
}
case Rotate: {
startElem *= 3;
endElem *= 3;
qreal from1, from2, from3;
qreal to1, to2, to3;
from1 = m_args[startElem++];
from2 = m_args[startElem++];
from3 = m_args[startElem++];
to1 = m_args[endElem++];
to2 = m_args[endElem++];
to3 = m_args[endElem++];
qreal rotationDiff = (to1 - from1) * percentOfAnimation;
//qreal rotation = from1 + rotationDiff;
qreal transXDiff = (to2-from2) * percentOfAnimation;
qreal transX = from2 + transXDiff;
qreal transYDiff = (to3-from3) * percentOfAnimation;
qreal transY = from3 + transYDiff;
m_transform = QTransform();
m_transform.translate(transX, transY);
m_transform.rotate(rotationDiff);
m_transform.translate(-transX, -transY);
break;
}
case SkewX: {
startElem *= 3;
endElem *= 3;
qreal from1;
qreal to1;
from1 = m_args[startElem++];
to1 = m_args[endElem++];
qreal transXDiff = (to1-from1) * percentOfAnimation;
qreal transX = from1 + transXDiff;
m_transform = QTransform();
m_transform.shear(qTan(transX * deg2rad), 0);
break;
}
case SkewY: {
startElem *= 3;
endElem *= 3;
qreal from1;
qreal to1;
from1 = m_args[startElem++];
to1 = m_args[endElem++];
qreal transYDiff = (to1 - from1) * percentOfAnimation;
qreal transY = from1 + transYDiff;
m_transform = QTransform();
m_transform.shear(0, qTan(transY * deg2rad));
break;
}
default:
break;
}
}
void dtkComposerNodeNumberOperatorUnaryTan::run(void)
{
double *value = d->receiver.data<double>();
*value = qTan(*value);
d->emitter.setData<double>(value);
}
void dtkComposerNodeTestCase::testNumberOperatorUnary(void)
{
double v_r = qAtan(1);
dtkComposerNodeReal n_r;
n_r.setValue(v_r);
n_r.run();
dtkComposerNodeReal n_end;
// INCREMENT
dtkComposerNodeNumberOperatorUnaryIncr n_incr;
QVERIFY(n_incr.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_incr.emitters().first()));
n_incr.run();
n_end.run();
QCOMPARE((v_r + 1), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_incr.emitters().first()));
// DECREMENT
dtkComposerNodeNumberOperatorUnaryDecr n_decr;
QVERIFY(n_decr.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_decr.emitters().first()));
n_decr.run();
n_end.run();
QCOMPARE((v_r - 1), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_decr.emitters().first()));
// SQRT
dtkComposerNodeNumberOperatorUnarySqrt n_sqrt;
QVERIFY(n_sqrt.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_sqrt.emitters().first()));
n_sqrt.run();
n_end.run();
QCOMPARE(qSqrt(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_sqrt.emitters().first()));
// SQUARE
dtkComposerNodeNumberOperatorUnarySquare n_square;
QVERIFY(n_square.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_square.emitters().first()));
n_square.run();
n_end.run();
QCOMPARE((v_r * v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_square.emitters().first()));
// LN
dtkComposerNodeNumberOperatorUnaryLn n_ln;
QVERIFY(n_ln.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_ln.emitters().first()));
n_ln.run();
n_end.run();
QCOMPARE(qLn(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_ln.emitters().first()));
// LOG10
dtkComposerNodeNumberOperatorUnaryLog10 n_log10;
QVERIFY(n_log10.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_log10.emitters().first()));
n_log10.run();
n_end.run();
QCOMPARE(qLn(v_r)/qLn(10.), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_log10.emitters().first()));
// EXP
dtkComposerNodeNumberOperatorUnaryExp n_exp;
QVERIFY(n_exp.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_exp.emitters().first()));
n_exp.run();
n_end.run();
QCOMPARE(qExp(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_exp.emitters().first()));
// COS
dtkComposerNodeNumberOperatorUnaryCos n_cos;
QVERIFY(n_cos.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_cos.emitters().first()));
n_cos.run();
n_end.run();
QCOMPARE(qCos(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_cos.emitters().first()));
// SIN
dtkComposerNodeNumberOperatorUnarySin n_sin;
QVERIFY(n_sin.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_sin.emitters().first()));
n_sin.run();
n_end.run();
QCOMPARE(qSin(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_sin.emitters().first()));
// TAN
dtkComposerNodeNumberOperatorUnaryTan n_tan;
QVERIFY(n_tan.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_tan.emitters().first()));
n_tan.run();
n_end.run();
QCOMPARE(qTan(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_tan.emitters().first()));
// ACOS
dtkComposerNodeNumberOperatorUnaryAcos n_acos;
QVERIFY(n_acos.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_acos.emitters().first()));
n_acos.run();
n_end.run();
QCOMPARE(qAcos(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_acos.emitters().first()));
// ASIN
dtkComposerNodeNumberOperatorUnaryAsin n_asin;
QVERIFY(n_asin.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_asin.emitters().first()));
n_asin.run();
n_end.run();
QCOMPARE(qAsin(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_asin.emitters().first()));
// ATAN
dtkComposerNodeNumberOperatorUnaryAtan n_atan;
QVERIFY(n_atan.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_atan.emitters().first()));
n_atan.run();
n_end.run();
QCOMPARE(qAtan(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_atan.emitters().first()));
// DEG2RAD
dtkComposerNodeNumberOperatorUnaryDeg2Rad n_d2r;
QVERIFY(n_d2r.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_d2r.emitters().first()));
n_d2r.run();
n_end.run();
QCOMPARE((v_r * M_PI / 180.), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_d2r.emitters().first()));
// RAD2DEG
dtkComposerNodeNumberOperatorUnaryRad2Deg n_r2d;
QVERIFY(n_r2d.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_r2d.emitters().first()));
n_r2d.run();
n_end.run();
QCOMPARE((v_r / M_PI * 180.), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_r2d.emitters().first()));
// INVERSE
dtkComposerNodeNumberOperatorUnaryInv n_inv;
QVERIFY(n_inv.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_inv.emitters().first()));
n_inv.run();
n_end.run();
QCOMPARE((1. / v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_inv.emitters().first()));
// OPPOSITE
dtkComposerNodeNumberOperatorUnaryOpp n_opp;
QVERIFY(n_opp.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_opp.emitters().first()));
n_opp.run();
n_end.run();
QCOMPARE((-v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_opp.emitters().first()));
// ABS
dtkComposerNodeNumberOperatorUnaryAbs n_abs;
QVERIFY(n_abs.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_end.receivers().first()->connect(n_abs.emitters().first()));
n_abs.run();
n_end.run();
QCOMPARE(qAbs(v_r), n_end.value());
QVERIFY(n_end.receivers().first()->disconnect(n_abs.emitters().first()));
dtkComposerNodeInteger n_iend;
// CEIL
dtkComposerNodeNumberOperatorUnaryCeil n_ceil;
QVERIFY(n_ceil.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_iend.receivers().first()->connect(n_ceil.emitters().first()));
n_ceil.run();
n_iend.run();
QCOMPARE(qCeil(v_r), static_cast<int>(n_iend.value()));
QVERIFY(n_iend.receivers().first()->disconnect(n_ceil.emitters().first()));
// FLOOR
dtkComposerNodeNumberOperatorUnaryFloor n_floor;
QVERIFY(n_floor.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_iend.receivers().first()->connect(n_floor.emitters().first()));
n_floor.run();
n_iend.run();
QCOMPARE(qFloor(v_r), static_cast<int>(n_iend.value()));
QVERIFY(n_iend.receivers().first()->disconnect(n_floor.emitters().first()));
// ROUND
dtkComposerNodeNumberOperatorUnaryRound n_round;
QVERIFY(n_round.receivers().first()->connect(n_r.emitters().first()));
QVERIFY(n_iend.receivers().first()->connect(n_round.emitters().first()));
n_round.run();
n_iend.run();
QCOMPARE(qRound(v_r), static_cast<int>(n_iend.value()));
QVERIFY(n_iend.receivers().first()->disconnect(n_round.emitters().first()));
}
void Bullet::move()
{
//move with rotation of tank
//convert degrees to radians
float degrees;
float radians;
if(game->player->rotation()<0)
{
degrees = -fmod(game->player->rotation() , 360)+90;
radians = qDegreesToRadians(degrees);
}
else
{
degrees = 90-fmod(game->player->rotation() , 360);
radians = qDegreesToRadians(degrees);
}
//move bullet
if(degrees==90)
setPos(x(),y()-5);
else if(degrees==270)
setPos(x(),y()+5);
else if(degrees>90 && degrees<270)
setPos(x()-5, y()+(qTan(radians)*5));
else if(degrees>270 && degrees<90)
setPos(x()+5, y()-(qTan(radians)*5));
//colliding bullet with objects
QList<QGraphicsItem *> items = collidingItems();
for(int i=0 ; i<items.size() ;i++)
{
if(typeid(*(items[i]))==typeid(Square)){
QVector<Object *>::Iterator it = game->objects.begin();
for(int j=0 ; j<game->objects.size() ;j++)
{
if(game->objects.at(j) == items[i])
{
if(game->objects.at(j)->health ==1)
{
scene()->removeItem(items[i]);
game->objects.erase(it+j);
}
else
{
game->objects.at(j)->health--;
}
}
}
game->score->increase();
scene()->removeItem(this);
delete this;
return;
}
if(typeid(*(items[i]))==typeid(Triangle)){
QVector<Object *>::Iterator it = game->objects.begin();
for(int j=0 ; j<game->objects.size() ;j++)
{
if(game->objects.at(j) == items[i])
{
if(game->objects.at(j)->health ==1)
{
scene()->removeItem(items[i]);
game->objects.erase(it+j);
}
else
{
game->objects.at(j)->health--;
}
}
}
game->score->increase();
scene()->removeItem(this);
delete this;
return;
}
if(typeid(*(items[i]))==typeid(Pentagon)){
QVector<Object *>::Iterator it = game->objects.begin();
for(int j=0 ; j<game->objects.size() ;j++)
{
if(game->objects.at(j) == items[i])
{
if(game->objects.at(j)->health ==1)
{
scene()->removeItem(items[i]);
game->objects.erase(it+j);
}
else
{
game->objects.at(j)->health--;
}
}
}
game->score->increase();
scene()->removeItem(this);
delete this;
return;
}
}
if(pos().y() < 0)
{
delete this;
}
}
UTMRef latLongToUtm(const QPointF &latlong)
{
UTMRef utm;
double UTM_F0 = 0.9996;
qreal a = 6378137.000;
qreal eSquared = ((a * a) - (6356752.3141 * 6356752.3141)) / (a * a);
double longitude = latlong.y();
double latitude = latlong.x();
double latitudeRad = latitude * (M_PI / 180.0);
double longitudeRad = longitude * (M_PI / 180.0);
int longitudeZone = (int) qFloor((longitude + 180.0) / 6.0) + 1;
// Special zone for Norway
if (latitude >= 56.0 && latitude < 64.0 && longitude >= 3.0
&& longitude < 12.0) {
longitudeZone = 32;
}
// Special zones for Svalbard
if (latitude >= 72.0 && latitude < 84.0) {
if (longitude >= 0.0 && longitude < 9.0) {
longitudeZone = 31;
} else if (longitude >= 9.0 && longitude < 21.0) {
longitudeZone = 33;
} else if (longitude >= 21.0 && longitude < 33.0) {
longitudeZone = 35;
} else if (longitude >= 33.0 && longitude < 42.0) {
longitudeZone = 37;
}
}
double longitudeOrigin = (longitudeZone - 1) * 6 - 180 + 3;
double longitudeOriginRad = longitudeOrigin * (M_PI / 180.0);
char UTMZone = getUTMLatitudeZoneLetter(latitude);
double ePrimeSquared = (eSquared) / (1 - eSquared);
double n = a / qSqrt(1 - eSquared * qSin(latitudeRad) * qSin(latitudeRad));
double t = qTan(latitudeRad) * qTan(latitudeRad);
double c = ePrimeSquared * qCos(latitudeRad) * qCos(latitudeRad);
double A = qCos(latitudeRad) * (longitudeRad - longitudeOriginRad);
double M = a * ((1 - eSquared / 4 - 3 * eSquared * eSquared / 64 - 5 * eSquared * eSquared * eSquared / 256)
* latitudeRad
- (3 * eSquared / 8 + 3 * eSquared * eSquared / 32 + 45
* eSquared * eSquared * eSquared / 1024)
* qSin(2 * latitudeRad)
+ (15 * eSquared * eSquared / 256 + 45 * eSquared * eSquared
* eSquared / 1024) * qSin(4 * latitudeRad) - (35
* eSquared * eSquared * eSquared / 3072)
* qSin(6 * latitudeRad));
double UTMEasting = (UTM_F0 * n * (A + (1 - t + c) * qPow(A, 3.0) / 6 + (5 - 18 * t + t * t
+ 72 * c - 58 * ePrimeSquared)
* qPow(A, 5.0) / 120) + 500000.0);
double UTMNorthing = (UTM_F0 * (M + n * qTan(latitudeRad)
* (A * A / 2 + (5 - t + (9 * c) + (4 * c * c)) * qPow(A, 4.0)
/ 24 + (61 - (58 * t) + (t * t) + (600 * c) - (330 * ePrimeSquared))
* qPow(A, 6.0) / 720)));
// Adjust for the southern hemisphere
if (latitude < 0) {
UTMNorthing += 10000000.0;
}
utm.position = QPointF(UTMEasting, UTMNorthing);
utm.latZ = UTMZone;
utm.lonZ = longitudeZone;
return utm;
}
