void KinematicPoints::SetS5C5()
{
s[5] = ctheta * (spsi * c[1] - cpsi * s[1]);
c[5] = delta5 * qSqrt(1 - qPow(s[5], 2));
fi[5] = qFabs(c[5])>qFabs(s[5])? qAsin(s[5]) : qAcos(c[5]);
//if(fi[5]!=fi[5]) {emit outOfRange(); return;}
}
qreal length( QPair<Node,Node> pair )
{
QPointF p1 = pair.first.coor();
QPointF p2 = pair.second.coor();
QPointF delta = p1 - p2;
return qSqrt(qPow(delta.x(),2)+qPow(delta.y(),2));
}
qreal UltimateTicTacToeMontecarloAI::nodeUCBValue(Node const& node, Nodes const& nodes) const {
if(node.parent != -1)
{
return node.v + c * qSqrt(qLn(nodes.at(node.parent).n) / node.n);
} else {
return 0;
}
}
void controlPoint::setAllowedMove(const QPointF& base, const QPointF& direction) {
allowedBase = base;
if (direction == QPointF(0,0)) {
allowedDirection = direction;
} else {
allowedDirection = direction/qSqrt(direction.x()*direction.x()+direction.y()*direction.y());
}
}
/*!
\fn QPolygon QMatrix::mapToPolygon(const QRect &rectangle) const
Creates and returns a QPolygon representation of the given \a
rectangle, mapped into the coordinate system defined by this
matrix.
The rectangle's coordinates are transformed using the following
formulas:
\snippet code/src_gui_painting_qmatrix.cpp 3
Polygons and rectangles behave slightly differently when
transformed (due to integer rounding), so
\c{matrix.map(QPolygon(rectangle))} is not always the same as
\c{matrix.mapToPolygon(rectangle)}.
\sa mapRect(), {QMatrix#Basic Matrix Operations}{Basic Matrix
Operations}
*/
QPolygon QMatrix::mapToPolygon(const QRect &rect) const
{
QPolygon a(4);
qreal x[4], y[4];
if (_m12 == 0.0F && _m21 == 0.0F) {
x[0] = _m11*rect.x() + _dx;
y[0] = _m22*rect.y() + _dy;
qreal w = _m11*rect.width();
qreal h = _m22*rect.height();
if (w < 0) {
w = -w;
x[0] -= w;
}
if (h < 0) {
h = -h;
y[0] -= h;
}
x[1] = x[0]+w;
x[2] = x[1];
x[3] = x[0];
y[1] = y[0];
y[2] = y[0]+h;
y[3] = y[2];
} else {
qreal right = rect.x() + rect.width();
qreal bottom = rect.y() + rect.height();
MAPDOUBLE(rect.x(), rect.y(), x[0], y[0]);
MAPDOUBLE(right, rect.y(), x[1], y[1]);
MAPDOUBLE(right, bottom, x[2], y[2]);
MAPDOUBLE(rect.x(), bottom, x[3], y[3]);
}
#if 0
int i;
for(i = 0; i< 4; i++)
qDebug("coords(%d) = (%f/%f) (%d/%d)", i, x[i], y[i], qRound(x[i]), qRound(y[i]));
qDebug("width=%f, height=%f", qSqrt((x[1]-x[0])*(x[1]-x[0]) + (y[1]-y[0])*(y[1]-y[0])),
qSqrt((x[0]-x[3])*(x[0]-x[3]) + (y[0]-y[3])*(y[0]-y[3])));
#endif
// all coordinates are correctly, tranform to a pointarray
// (rounding to the next integer)
a.setPoints(4, qRound(x[0]), qRound(y[0]),
qRound(x[1]), qRound(y[1]),
qRound(x[2]), qRound(y[2]),
qRound(x[3]), qRound(y[3]));
return a;
}
void DistortionFXFilter::polarCoordinatesMultithreaded(const Args& prm)
{
int Width = prm.orgImage->width();
int Height = prm.orgImage->height();
uchar* data = prm.orgImage->bits();
bool sixteenBit = prm.orgImage->sixteenBit();
int bytesDepth = prm.orgImage->bytesDepth();
uchar* pResBits = prm.destImage->bits();
int nHalfW = Width / 2;
int nHalfH = Height / 2;
double lfXScale = 1.0;
double lfYScale = 1.0;
double lfAngle, lfRadius, lfRadMax;
double nh, nw, tw;
if (Width > Height)
{
lfYScale = (double)Width / (double)Height;
}
else if (Height > Width)
{
lfXScale = (double)Height / (double)Width;
}
lfRadMax = (double)qMax(Height, Width) / 2.0;
double th = lfYScale * (double)(prm.h - nHalfH);
for (int w = prm.start; runningFlag() && (w < prm.stop); ++w)
{
tw = lfXScale * (double)(w - nHalfW);
if (prm.Type)
{
// now, we get the distance
lfRadius = qSqrt(th * th + tw * tw);
// we find the angle from the center
lfAngle = qAtan2(tw, th);
// now we find the exact position's x and y
nh = lfRadius * (double) Height / lfRadMax;
nw = lfAngle * (double) Width / (2 * M_PI);
nw = (double)nHalfW + nw;
}
else
{
lfRadius = (double)(prm.h) * lfRadMax / (double)Height;
lfAngle = (double)(w) * (2 * M_PI) / (double) Width;
nw = (double)nHalfW - (lfRadius / lfXScale) * qSin(lfAngle);
nh = (double)nHalfH - (lfRadius / lfYScale) * qCos(lfAngle);
}
setPixelFromOther(Width, Height, sixteenBit, bytesDepth, data, pResBits, w, prm.h, nw, nh, prm.AntiAlias);
}
}
void BenchWidget::paintEvent(QPaintEvent *)
{
if (m_done)
return;
QPainter p(this);
m_benchmark->begin(&p, 100);
PaintingRectAdjuster adjuster;
adjuster.setNewBenchmark(m_benchmark);
adjuster.reset(rect());
for (int i = 0; i < 100; ++i)
m_benchmark->draw(&p, adjuster.newPaintingRect(), i);
m_benchmark->end(&p);
++m_iteration;
uint currentElapsed = timer.isNull() ? 0 : timer.elapsed();
timer.restart();
m_total += currentElapsed;
// warm up for at most 5 iterations or half a second
if (m_iteration >= 5 || m_total >= 500) {
iterationTimes << currentElapsed;
if (iterationTimes.size() >= 5) {
qreal mean = 0;
qreal stddev = 0;
uint min = INT_MAX;
for (int i = 0; i < iterationTimes.size(); ++i) {
mean += iterationTimes.at(i);
min = qMin(min, iterationTimes.at(i));
}
mean /= qreal(iterationTimes.size());
for (int i = 0; i < iterationTimes.size(); ++i) {
qreal delta = iterationTimes.at(i) - mean;
stddev += delta * delta;
}
stddev = qSqrt(stddev / iterationTimes.size());
stddev = 100 * stddev / mean;
// do 50 iterations, break earlier if we spend more than 5 seconds or have a low std deviation after 2 seconds
if (iterationTimes.size() >= 50 || m_total >= 5000 || (m_total >= 2000 && stddev < 4)) {
m_result = min;
m_done = true;
return;
}
}
}
}
void Calculator::calculate()
{
double operand2 = m_stk.pop().toDouble();
QString strOperation = m_stk.pop();
double operand1 = m_stk.pop().toDouble();
double Result_d = 0;
if (strOperation == "+") {
Result_d = operand1+operand2;
}
if (strOperation == "-")
{
Result_d = operand1-operand2;
}
if (strOperation == "/")
{
Result_d = operand1 / operand2;
}
if (strOperation == "*")
{
Result_d = operand1 * operand2;
}
if (strOperation == "Pow")
{
Result_d=qPow(operand1,operand2);
}
if (strOperation == "M-")
{
subs_memory(operand1);
}
if (strOperation == "M+")
{
add_memory(operand1);
}
if (strOperation == "MS")
{
reset_memory();
}
if (strOperation == "Sqrt")
{
Result_d=qSqrt(operand1);
}
if (strOperation == "ln")
{
Result_d=qLn(operand1);
}
if (strOperation == "MR")
{
Result_d=get_memory();
}
if (strOperation == "abs")
{
Result_d=qAbs(operand1);
}
m_plcd->display(Result_d );
}
void KinematicPoints::SetAB()
{
double xr = regionalPoint.x();
double yr = regionalPoint.y();
double zr = regionalPoint.z();
a = (-1.0)*l[1] + delta1* qSqrt(qPow(xr, 2) + qPow(yr, 2) - qPow(e, 2));
b = 0.5/l[2] * (qPow(a, 2) + qPow(zr, 2) + qPow(l[2], 2) - qPow(l[3], 2));
}
Number Derivative::smallNumber(Number x)
{
if (!MathUtils::isNull(x)) {
return qSqrt(MathUtils::machineEpsilon()) * x;
}
else {
return MathUtils::machineEpsilon();
}
}
void CurveDrawer::fillCircle(const QPointF& center, qreal diameter)
{
qreal radius = diameter / 2;
for (int sy = -1; sy <= 1; sy += 2)
{
qreal d;
for (QPoint p(Utils::roundPoint(center)); (d = qSqrt(Utils::normSquared(p - center)) - radius) <= 0; p.ry() += sy)
{
for (int sx = -1; sx <= 1; sx += 2)
{
for (QPoint pp(p); (d = qSqrt(Utils::normSquared(pp - center)) - radius) <= 0; pp.rx() += sx)
{
setPixel(pp, pixelColor(d, 0.));
}
}
}
}
}
double getRange(const QPointF &a,const QPointF &b)
{
double dx = a.x() - b.x();
double dx2 = dx*dx;
double dy = a.y() - b.y();
double dy2 = dy*dy;
double r = qSqrt(dx2 + dy2);
return r;
}
double LevelOneDec::getMu(int i)
{
double mu = 0;
for (size_t j = 0; j < col; ++j)
{
mu += qPow(vectorSensorReadings2DToLevelOne[i][j], 2);
}
return qSqrt(mu);
}
double Nodos::distancia_linea_recta(int inix, int iniy, int metax, int metay)
{
double adx=abs(metax - inix);
double ady=abs(metay - iniy);
double distancia = qSqrt((qPow(adx,2)+(qPow(ady,2))));
return distancia;
cout<<"Entro en distancia_linea"<<endl;
}
double LevelOneDec::getMuLowerLimit(size_t i)
{
double mu_lower_limit = 0;
for (size_t j = 0; j < col; ++j)
{
mu_lower_limit += qPow(vector2DSensorReadingsLow[i][j], 2);
}
return qSqrt(mu_lower_limit);
}
QPointF CvHelper::norm(double x, double y)
{
double distance = qSqrt(x * x + y * y);
if (distance == 0) {
return QPointF(0, 0);
}
return QPointF(x / distance, y / distance);
}
double LevelOneDec::getMuHighLimit(size_t i)
{
double mu_high_limit = 0;
for (size_t j = 0; j < col; ++j)
{
mu_high_limit += qPow(vector2DSensorReadingsHigh[i][j], 2);
}
return qSqrt(mu_high_limit);
}
float
CurveGroup::pathLength(Curve *c)
{
// find total path length
int xcount = c->pts.count();
double plen = 0;
for (int i=1; i<xcount; i++)
{
QPoint v = c->pts[i]-c->pts[i-1];
plen += qSqrt(QPoint::dotProduct(v,v));
}
if (c->closed) // for closed curve
{
QPoint v = c->pts[0]-c->pts[xcount-1];
plen += qSqrt(QPoint::dotProduct(v,v));
}
return plen;
}
TileOutline::TileOutline(Qt::GlobalColor color, QGraphicsItem *parent):QGraphicsPolygonItem(parent)
{
QPen pen(color,2);
setPen(pen);
//set points for hexagon
QVector<QPointF> points;
points << QPointF(-1.0/(qSqrt(3)),-1) << QPointF(1.0/(qSqrt(3)),-1) << QPointF(2.0/(qSqrt(3)),0)
<< QPointF(1.0/(qSqrt(3)),1) << QPointF(-1.0/(qSqrt(3)),1) << QPointF(-2.0/(qSqrt(3)),0);
//scale hexagon
for(size_t i = 0,n = points.size();i<n;i++)
{
points[i]*=HEX_SCALE;
}
setPolygon(QPolygonF(points));
}
bool LambertAzimuthalProjection::screenCoordinates( const GeoDataCoordinates &coordinates,
const ViewportParams *viewport,
qreal &x, qreal &y, bool &globeHidesPoint ) const
{
const qreal lambda = coordinates.longitude();
const qreal phi = coordinates.latitude();
const qreal lambdaPrime = viewport->centerLongitude();
const qreal phi1 = viewport->centerLatitude();
qreal cosC = qSin( phi1 ) * qSin( phi ) + qCos( phi1 ) * qCos( phi ) * qCos( lambda - lambdaPrime );
// Prevent division by zero
if (cosC <= 0) {
globeHidesPoint = true;
return false;
}
qreal k = qSqrt(2 / (1 + cosC));
// Let (x, y) be the position on the screen of the placemark..
x = ( qCos( phi ) * qSin( lambda - lambdaPrime ) ) * k;
y = ( qCos( phi1 ) * qSin( phi ) - qSin( phi1 ) * qCos( phi ) * qCos( lambda - lambdaPrime ) ) * k;
x *= viewport->radius() / qSqrt(2);
y *= viewport->radius() / qSqrt(2);
const qint64 radius = clippingRadius() * viewport->radius();
if (x*x + y*y > radius * radius) {
globeHidesPoint = true;
return false;
}
globeHidesPoint = false;
x += viewport->width() / 2;
y = viewport->height() / 2 - y;
// Skip placemarks that are outside the screen area
if ( x < 0 || x >= viewport->width() || y < 0 || y >= viewport->height() ) {
return false;
}
return true;
}
void SectorHistogram::construct( const Billon &billon, const Interval<uint> &sliceInterval, const Interval<int> &intensity,
const uint &zMotionMin, const int &radiusAroundPith )
{
clear();
if ( billon.hasPith() && sliceInterval.isValid() && sliceInterval.width() > 0 )
{
const int &width = billon.n_cols;
const int &height = billon.n_rows;
const qreal squareRadius = qPow(radiusAroundPith,2);
fill(0.,PieChartSingleton::getInstance()->nbSectors());
QVector<int> circleLines;
circleLines.reserve(2*radiusAroundPith+1);
for ( int lineIndex=-radiusAroundPith ; lineIndex<=radiusAroundPith ; ++lineIndex )
{
circleLines.append(qSqrt(squareRadius-qPow(lineIndex,2)));
}
QVector<int>::ConstIterator circlesLinesIterator;
int iRadius;
uint diff;
iCoord2D currentPos;
// Calcul du diagramme en parcourant les tranches du billon comprises dans l'intervalle
for ( uint k=sliceInterval.min() ; k<=sliceInterval.max() ; ++k )
{
const Slice ¤tSlice = billon.slice(k);
const Slice &previousSlice = billon.previousSlice(k);
const iCoord2D ¤tPithCoord = billon.pithCoord(k);
currentPos.y = currentPithCoord.y-radiusAroundPith;
for ( circlesLinesIterator = circleLines.constBegin() ; circlesLinesIterator != circleLines.constEnd() ; ++circlesLinesIterator )
{
iRadius = *circlesLinesIterator;
currentPos.x = currentPithCoord.x-iRadius;
iRadius += currentPithCoord.x;
while ( currentPos.x <= iRadius )
{
if ( currentPos.x < width && currentPos.y < height && intensity.containsOpen(currentSlice.at(currentPos.y,currentPos.x)) &&
intensity.containsOpen(previousSlice.at(currentPos.y,currentPos.x)) )
{
diff = billon.zMotion(currentPos.x,currentPos.y,k);
//if ( motionInterval.containsClosed(diff) )
if ( diff >= zMotionMin )
{
(*this)[PieChartSingleton::getInstance()->sectorIndexOfAngle( currentPithCoord.angle(currentPos) )] += diff-zMotionMin;
}
}
currentPos.x++;
}
currentPos.y++;
}
}
}
}
QPolygonF QwtSplineCurveFitter::fitParametric( const QPolygonF &points ) const
{
int i;
const int size = points.size();
QPolygonF fittedPoints( d_data->splineSize );
QPolygonF splinePointsX( size );
QPolygonF splinePointsY( size );
const QPointF *p = points.data();
QPointF *spX = splinePointsX.data();
QPointF *spY = splinePointsY.data();
double param = 0.0;
for ( i = 0; i < size; i++ )
{
const double x = p[i].x();
const double y = p[i].y();
if ( i > 0 )
{
const double delta = qSqrt( qwtSqr( x - spX[i-1].y() )
+ qwtSqr( y - spY[i-1].y() ) );
param += qMax( delta, 1.0 );
}
spX[i].setX( param );
spX[i].setY( x );
spY[i].setX( param );
spY[i].setY( y );
}
d_data->spline.setPoints( splinePointsX );
if ( !d_data->spline.isValid() )
return points;
const double deltaX =
splinePointsX[size - 1].x() / ( d_data->splineSize - 1 );
for ( i = 0; i < d_data->splineSize; i++ )
{
const double dtmp = i * deltaX;
fittedPoints[i].setX( qRound( d_data->spline.value( dtmp ) ) );
}
d_data->spline.setPoints( splinePointsY );
if ( !d_data->spline.isValid() )
return points;
const double deltaY =
splinePointsY[size - 1].x() / ( d_data->splineSize - 1 );
for ( i = 0; i < d_data->splineSize; i++ )
{
const double dtmp = i * deltaY;
fittedPoints[i].setY( qRound( d_data->spline.value( dtmp ) ) );
}
return fittedPoints;
}
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;
}
virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value){
if(change == ItemPositionHasChanged){
QGraphicsEllipseItem *item = qgraphicsitem_cast<QGraphicsEllipseItem *>(parentItem());
qreal diff = qSqrt(x()*x() + y()*y());
item->setRect(MakeCircleRect(diff - kCropItemControlPointRadius));
}
return QGraphicsEllipseItem::itemChange(change, value);
}
void CurveFitter::initBins()
{
for (int i = 0; i < SPLINE_ORDER; ++i) {
int a = qMax(i, SPLINE_ORDER - 1 - i);
bins[i] = 1.0;
for (int j = a + 1; j <= SPLINE_ORDER - 1; ++j)
bins[i] *= (qreal) j / (j - a);
}
resPhi = 2 - (1 + qSqrt(5)) / 2;
}
bool VerticalPerspectiveProjection::geoCoordinates( const int x, const int y,
const ViewportParams *viewport,
qreal& lon, qreal& lat,
GeoDataCoordinates::Unit unit ) const
{
Q_D(const VerticalPerspectiveProjection);
d->calculateConstants(viewport->radius());
const qreal P = d->m_P;
const qreal rx = ( - viewport->width() / 2 + x );
const qreal ry = ( viewport->height() / 2 - y );
const qreal p2 = rx*rx + ry*ry;
if (p2 == 0) {
lon = viewport->centerLongitude();
lat = viewport->centerLatitude();
return true;
}
const qreal pP = p2*d->m_pPfactor;
if ( pP > 1) return false;
const qreal p = qSqrt(p2);
const qreal fract = d->m_perspectiveRadius*(P-1)/p;
const qreal c = qAsin((P-qSqrt(1-pP))/(fract+1/fract));
const qreal sinc = qSin(c);
const qreal centerLon = viewport->centerLongitude();
const qreal centerLat = viewport->centerLatitude();
lon = centerLon + qAtan2(rx*sinc, (p*qCos(centerLat)*qCos(c) - ry*qSin(centerLat)*sinc));
while ( lon < -M_PI ) lon += 2 * M_PI;
while ( lon > M_PI ) lon -= 2 * M_PI;
lat = qAsin(qCos(c)*qSin(centerLat) + (ry*sinc*qCos(centerLat))/p);
if ( unit == GeoDataCoordinates::Degree ) {
lon *= RAD2DEG;
lat *= RAD2DEG;
}
return true;
}
Rpn::Operand SquareRoot::calculate(FunctionCalculator *calculator, QList<Rpn::Operand> actualArguments)
{
Q_UNUSED(calculator);
Rpn::Operand result;
result.type = Rpn::OperandNumber;
result.value = qSqrt(actualArguments.at(0).value.value<Number>());
return result;
}
QColor ColorWheel::posColor(const QPoint &point)
{
if( ! wheel.rect().contains(point) ) return QColor();
if(inWheel){
qreal hue = 0;
int r = qMin(width(), height()) / 2;
if( point.x() > r ){
if(point.y() < r ){
//1
hue = 90 - (qAtan2( (point.x() - r) , (r - point.y()) ) / 3.14 / 2 * 360);
}else{
//4
hue = 270 + (qAtan2( (point.x() - r) , (point.y() - r ) ) / 3.14 / 2 * 360);
}
}else{
if(point.y() < r ){
//2
hue = 90 + (qAtan2( (r - point.x()) , (r - point.y()) ) / 3.14 / 2 * 360);
}else{
//3
hue = 270 - (qAtan2( (r - point.x()) , (point.y() - r )) / 3.14 / 2 * 360);
}
}
hue = hue>359?359:hue;
hue = hue<0?0:hue;
return QColor::fromHsv(hue, current.saturation(), current.value() );
}
if(inSquare){
// region of the widget
int w = qMin(width(), height());
// radius of outer circle
qreal r = w/2-margin;
// radius of inner circle
qreal ir = r-wheelWidth;
// left corner of square
qreal m = w/2.0-ir/qSqrt(2);
QPoint p = point - QPoint(m, m);
qreal SquareWidth = 2*ir/qSqrt(2);
return QColor::fromHsvF( current.hueF(), p.x()/SquareWidth, p.y()/SquareWidth );
}
return QColor();
}
QColor ColorWheel::colorPosition(const QPoint &point)
{
if( ! wheel.rect().contains(point) ) return QColor();
if(selectedWheel){
qreal hue = 0;
int r = qMin(width(), height()) / 2;
if( point.x() > r ){
if(point.y() < r ){
//1
hue = 90 - (qAtan2( (point.x() - r) , (r - point.y()) ) / 3.14 / 2 * 360);
}else{
//4
hue = 270 + (qAtan2( (point.x() - r) , (point.y() - r ) ) / 3.14 / 2 * 360);
}
}else{
if(point.y() < r ){
//2
hue = 90 + (qAtan2( (r - point.x()) , (r - point.y()) ) / 3.14 / 2 * 360);
}else{
//3
hue = 270 - (qAtan2( (r - point.x()) , (point.y() - r )) / 3.14 / 2 * 360);
}
}
hue = hue>359?359:hue;
hue = hue<0?0:hue;
return QColor::fromHsv(hue,
start.saturation(),
start.value());
}
if(selected){
int w = qMin(width(), height());
qreal r = w/2-margin;
qreal ir = r-wWidth;
qreal m = w/2.0-ir/qSqrt(2);
QPoint p = point - QPoint(m, m);
qreal SquareWidth = 2*ir/qSqrt(2);
return QColor::fromHsvF( start.hueF(),
p.x()/SquareWidth,
p.y()/SquareWidth);
}
return QColor();
}
/*!
* \brief Reading::errorPropagationPolarToCart
* Variance propagation to get sigma values for cartesian coordinates
* \return
*/
OiVec Reading::errorPropagationPolarToCart(){
OiVec sigmaCartXyz;
OiMat F(3,3);
F.setAt(0, 0, qSin(this->rPolar.zenith) * qCos(this->rPolar.azimuth));
F.setAt(0, 1, this->rPolar.distance * qSin(this->rPolar.zenith) * -qSin(this->rPolar.azimuth));
F.setAt(0, 2, this->rPolar.distance * qCos(this->rPolar.zenith) * qCos(this->rPolar.azimuth));
F.setAt(1, 0, qSin(this->rPolar.zenith) * qSin(this->rPolar.azimuth));
F.setAt(1, 1, this->rPolar.distance * qSin(this->rPolar.zenith) * qCos(this->rPolar.azimuth));
F.setAt(1, 2, this->rPolar.distance * qCos(this->rPolar.zenith) * qSin(this->rPolar.azimuth));
F.setAt(2, 0, qCos(this->rPolar.zenith));
F.setAt(2, 1, 0.0);
F.setAt(2, 2, this->rPolar.distance * -qSin(this->rPolar.zenith));
OiMat Sll(3,3);
Sll.setAt(0, 0, this->rPolar.sigmaDistance * this->rPolar.sigmaDistance);
Sll.setAt(1, 1, this->rPolar.sigmaAzimuth * this->rPolar.sigmaAzimuth);
Sll.setAt(2, 2, this->rPolar.sigmaZenith * this->rPolar.sigmaZenith);
OiMat Qxx = F * Sll * F.t();
//transform Qxx into homogeneous coordinates
OiMat Qxx_hc(4,4);
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
Qxx_hc.setAt(i,j, Qxx.getAt(i,j));
}
}
sigmaCartXyz.add(qSqrt(Qxx.getAt(0,0)));
sigmaCartXyz.add(qSqrt(Qxx.getAt(1,1)));
sigmaCartXyz.add(qSqrt(Qxx.getAt(2,2)));
sigmaCartXyz.add(1.0);
if(this->obs != NULL){
this->obs->myStatistic.qxx = Qxx_hc;
this->obs->myStatistic.s0_apriori = 1.0;
this->obs->myOriginalStatistic = this->obs->myStatistic;
}
return sigmaCartXyz;
}
