QGeoCoordinate QGeoProjection::coordinateInterpolation(const QGeoCoordinate &from, const QGeoCoordinate &to, qreal progress)
{
QDoubleVector2D s = QGeoProjection::coordToMercator(from);
QDoubleVector2D e = QGeoProjection::coordToMercator(to);
double x = s.x();
if (0.5 < qAbs(e.x() - s.x())) {
// handle dateline crossing
double ex = e.x();
double sx = s.x();
if (ex < sx)
sx -= 1.0;
else if (sx < ex)
ex -= 1.0;
x = (1.0 - progress) * sx + progress * ex;
if (!qFuzzyIsNull(x) && (x < 0.0))
x += 1.0;
} else {
x = (1.0 - progress) * s.x() + progress * e.x();
}
double y = (1.0 - progress) * s.y() + progress * e.y();
QGeoCoordinate result = QGeoProjection::mercatorToCoord(QDoubleVector2D(x, y));
result.setAltitude((1.0 - progress) * from.altitude() + progress * to.altitude());
return result;
}
void type_data()
{
QTest::addColumn<QGeoCoordinate>("c");
QTest::addColumn<QGeoCoordinate::CoordinateType>("type");
QGeoCoordinate c;
QTest::newRow("no values set") << c << QGeoCoordinate::InvalidCoordinate;
c.setAltitude(1.0);
QTest::newRow("only altitude is set") << c << QGeoCoordinate::InvalidCoordinate;
c.setLongitude(1.0);
QTest::newRow("only latitude and altitude is set") << c << QGeoCoordinate::InvalidCoordinate;
c.setLatitude(-1.0);
QTest::newRow("all valid: 3D Coordinate") << c << QGeoCoordinate::Coordinate3D;
c.setLatitude(-90.1);
QTest::newRow("too low latitude and valid longitude") << c << QGeoCoordinate::InvalidCoordinate;
c.setLongitude(-180.1);
c.setLatitude(90.0);
QTest::newRow("valid latitude and too low longitude") << c << QGeoCoordinate::InvalidCoordinate;
c.setLatitude(90.1);
c.setLongitude(-180.0);
QTest::newRow("too high latitude and valid longitude") << c << QGeoCoordinate::InvalidCoordinate;
c.setLatitude(-90.0);
c.setLongitude(180.1);
QTest::newRow("valid latitude and too high longitude") << c << QGeoCoordinate::InvalidCoordinate;
}
void PointInPolygonWidget::positionUpdated(const QGeoPositionInfo &info)
{
QGeoPositionInfo pos_info = info;
QGeoCoordinate pos = pos_info.coordinate();
if (pos.isValid()) {
ui->xNewPoint->setValue(pos.latitude());
ui->yNewPoint->setValue(pos.longitude());
ui->xPoint->setValue(pos.latitude());
ui->yPoint->setValue(pos.longitude());
double dist = 0;
if (is_first_distance_) {
dist_acc_ = 0;
is_first_distance_ = false;
} else {
if (std::fabs(pos.altitude()) < 1e-3) {
pos.setAltitude(last_position_.coordinate().altitude());
pos_info.setCoordinate(pos);
}
dist = pos_info.coordinate().distanceTo(last_position_.coordinate());
if (dist > 10) {
dist_acc_ += dist;
}
}
last_position_ = pos_info;
}
}
/*!
\internal
*/
void QDeclarativeRectangleMapItem::dragEnded()
{
QPointF newTopLeftPoint = QPointF(x(),y());
QGeoCoordinate newTopLeft = map()->screenPositionToCoordinate(newTopLeftPoint, false);
if (newTopLeft.isValid()) {
// calculate new geo width while checking for dateline crossing
const double lonW = bottomRight_.longitude() > topLeft_.longitude() ?
bottomRight_.longitude() - topLeft_.longitude() :
bottomRight_.longitude() + 360 - topLeft_.longitude();
const double latH = qAbs(bottomRight_.latitude() - topLeft_.latitude());
QGeoCoordinate newBottomRight;
// prevent dragging over valid min and max latitudes
if (QLocationUtils::isValidLat(newTopLeft.latitude() - latH)) {
newBottomRight.setLatitude(newTopLeft.latitude() - latH);
} else {
newBottomRight.setLatitude(QLocationUtils::clipLat(newTopLeft.latitude() - latH));
newTopLeft.setLatitude(newBottomRight.latitude() + latH);
}
// handle dateline crossing
newBottomRight.setLongitude(QLocationUtils::wrapLong(newTopLeft.longitude() + lonW));
newBottomRight.setAltitude(newTopLeft.altitude());
topLeft_ = newTopLeft;
bottomRight_ = newBottomRight;
geometry_.setPreserveGeometry(true, newTopLeft);
borderGeometry_.setPreserveGeometry(true, newTopLeft);
geometry_.markSourceDirty();
borderGeometry_.markSourceDirty();
updateMapItem();
emit topLeftChanged(topLeft_);
emit bottomRightChanged(bottomRight_);
}
}
void CLbsPositionLogger::readNextPosition()
{
QByteArray line = m_logFile.readLine().trimmed();
if (line.isEmpty()) {
LOG_MODEL_ERROR("CLbsPositionLogger", "no readlien");
return;
}
QList<QByteArray> data = line.split(',');
QGeoCoordinate coordinate;
QGeoPositionInfo info;
bool hasTimestamp = false;
QDateTime timestamp = QDateTime::fromTime_t(data.value(0).toLong(&hasTimestamp), Qt::UTC);
if(hasTimestamp && timestamp.isValid())
info.setTimestamp(timestamp);
double latitude;
bool hasLatitude = false;
latitude = data.value(1).toDouble(&hasLatitude);
if(hasLatitude)
coordinate.setLatitude(latitude);
double longitude;
bool hasLongitude = false;
longitude = data.value(2).toDouble(&hasLongitude);
if(hasLongitude)
coordinate.setLongitude(longitude);
double altitude;
bool hasAltitude = false;
altitude = data.value(3).toDouble(&hasAltitude);
if(hasAltitude)
coordinate.setAltitude(altitude);
info.setCoordinate(coordinate);
double HorizontalAccuracy;
bool hasHorizontalAccuracy = false;
HorizontalAccuracy = data.value(4).toDouble(&hasHorizontalAccuracy);
if(hasHorizontalAccuracy)
info.setAttribute(QGeoPositionInfo::HorizontalAccuracy, HorizontalAccuracy);
double Direction;
bool hasDirection = false;
Direction = data.value(5).toDouble(&hasDirection);
if(hasDirection)
info.setAttribute(QGeoPositionInfo::Direction, Direction);
double GroundSpeed;
bool hasGroundSpeed = false;
GroundSpeed = data.value(6).toDouble(&hasGroundSpeed);
if(hasGroundSpeed)
info.setAttribute(QGeoPositionInfo::GroundSpeed, GroundSpeed);
if (info.isValid()) {
m_lastPosition = info;
emit positionUpdated(info);
}
}
void altitude()
{
QFETCH(double, value);
QGeoCoordinate c;
c.setAltitude(value);
QCOMPARE(c.altitude(), value);
QGeoCoordinate c2 = c;
QCOMPARE(c.altitude(), value);
QCOMPARE(c2, c);
}
void QGeoMapController::pan(qreal dx, qreal dy)
{
if (dx == 0 && dy == 0)
return;
QGeoCameraData cd = map_->cameraData();
QGeoCoordinate coord = map_->itemPositionToCoordinate(
QDoubleVector2D(map_->width() / 2 + dx,
map_->height() / 2 + dy));
// keep altitude as it was
coord.setAltitude(cd.center().altitude());
if (coord.isValid()) {
cd.setCenter(coord);
map_->setCameraData(cd);
}
}
QPlace QPlaceManagerEngineJsonDb::compatiblePlace(const QPlace &original) const
{
QPlace place;
place.setName(original.name());
QGeoLocation location = original.location();
QGeoCoordinate coord = original.location().coordinate();
coord.setAltitude(qQNaN());
location.setCoordinate(coord);
location.setBoundingBox(QGeoRectangle());
place.setLocation(location);
QList<QPlaceContactDetail> details;
foreach (const QString &contactType, original.contactTypes())
place.setContactDetails(contactType, original.contactDetails(contactType));
place.setVisibility(QLocation::UnspecifiedVisibility);
QStringList attributeTypes = original.extendedAttributeTypes();
foreach (const QString &attributeType, attributeTypes)
place.setExtendedAttribute(attributeType, original.extendedAttribute(attributeType));
QString provider = original.extendedAttribute(QLatin1String("x_provider")).text();
if (!provider.isEmpty()) {
QPlaceAttribute alternativeId;
alternativeId.setText(original.placeId());
place.setExtendedAttribute(QString::fromLatin1("x_id_") + provider,
alternativeId);
if (provider == QLatin1String("nokia") || provider == QLatin1String("nokia_mos")) {
QStringList nokiaCategoryIds;
foreach (const QPlaceCategory &cat, original.categories()) {
if (!cat.categoryId().isEmpty())
nokiaCategoryIds.append(cat.categoryId());
}
if (!nokiaCategoryIds.isEmpty()) {
QPlaceAttribute nokiaCatIds;
nokiaCatIds.setText(nokiaCategoryIds.join(QLatin1String(",")));
place.setExtendedAttribute(QString::fromLatin1("x_nokia_category_ids"), nokiaCatIds);
}
}
QGeoCoordinate QGeoCoordinateInterpolator2D::interpolate(const QGeoCoordinate &start, const QGeoCoordinate &end, qreal progress)
{
if (start == end) {
if (progress < 0.5) {
return start;
} else {
return end;
}
}
QGeoCoordinate s2 = start;
QGeoCoordinate e2 = end;
QDoubleVector2D s = QGeoProjection::coordToMercator(s2);
QDoubleVector2D e = QGeoProjection::coordToMercator(e2);
double x = s.x();
if (0.5 < qAbs(e.x() - s.x())) {
// handle dateline crossing
double ex = e.x();
double sx = s.x();
if (ex < sx)
sx -= 1.0;
else if (sx < ex)
ex -= 1.0;
x = (1.0 - progress) * sx + progress * ex;
if (!qFuzzyIsNull(x) && (x < 0.0))
x += 1.0;
} else {
x = (1.0 - progress) * s.x() + progress * e.x();
}
double y = (1.0 - progress) * s.y() + progress * e.y();
QGeoCoordinate result = QGeoProjection::mercatorToCoord(QDoubleVector2D(x, y));
result.setAltitude((1.0 - progress) * start.altitude() + progress * end.altitude());
return result;
}
QList<QGeoPositionInfo> gpxfile::loadFrom(const QString fileName) {
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "File open error:" << file.errorString();
// return false;
}
QXmlStreamReader xml(&file);
QList<QGeoPositionInfo> trackList;
trackList.clear();
QGeoPositionInfo tp;
QGeoCoordinate coord;
QDateTime ts;
while (!xml.atEnd() && !xml.hasError())
{
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "trkpt") {
coord.setLongitude(xml.attributes().value("lon").toFloat());
coord.setLatitude(xml.attributes().value("lat").toFloat());
while (xml.readNextStartElement()) {
if (xml.name() == "ele")
coord.setAltitude(xml.readElementText().toFloat());
else if (xml.name() == "time")
ts = QDateTime::fromString(xml.readElementText(),"yyyy-MM-dd'T'hh:mm:ss'Z'");
} //ele, time
tp.setCoordinate(coord);
tp.setTimestamp(ts);
trackList.append(tp);
} //trkpt
} //content
} //eof
return(trackList);
}
/*!
\internal
*/
void QDeclarativeRectangleMapItem::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
{
if (updatingGeometry_ || newGeometry.topLeft() == oldGeometry.topLeft()) {
QDeclarativeGeoMapItemBase::geometryChanged(newGeometry, oldGeometry);
return;
}
QDoubleVector2D newTopLeftPoint = QDoubleVector2D(x(),y());
QGeoCoordinate newTopLeft = map()->itemPositionToCoordinate(newTopLeftPoint, false);
if (newTopLeft.isValid()) {
// calculate new geo width while checking for dateline crossing
const double lonW = bottomRight_.longitude() > topLeft_.longitude() ?
bottomRight_.longitude() - topLeft_.longitude() :
bottomRight_.longitude() + 360 - topLeft_.longitude();
const double latH = qAbs(bottomRight_.latitude() - topLeft_.latitude());
QGeoCoordinate newBottomRight;
// prevent dragging over valid min and max latitudes
if (QLocationUtils::isValidLat(newTopLeft.latitude() - latH)) {
newBottomRight.setLatitude(newTopLeft.latitude() - latH);
} else {
newBottomRight.setLatitude(QLocationUtils::clipLat(newTopLeft.latitude() - latH));
newTopLeft.setLatitude(newBottomRight.latitude() + latH);
}
// handle dateline crossing
newBottomRight.setLongitude(QLocationUtils::wrapLong(newTopLeft.longitude() + lonW));
newBottomRight.setAltitude(newTopLeft.altitude());
topLeft_ = newTopLeft;
bottomRight_ = newBottomRight;
geometry_.setPreserveGeometry(true, newTopLeft);
borderGeometry_.setPreserveGeometry(true, newTopLeft);
markSourceDirtyAndUpdate();
emit topLeftChanged(topLeft_);
emit bottomRightChanged(bottomRight_);
}
// Not calling QDeclarativeGeoMapItemBase::geometryChanged() as it will be called from a nested
// call to this function.
}
bool QLandmarkFileHandlerGpx::readWaypoint(QLandmark &landmark, const QString &elementName)
{
/*
<xsd:complexType name="wptType">
<xsd:sequence>
<xsd:element name="ele" type="xsd:decimal" minOccurs="0" />
<xsd:element name="time" type="xsd:dateTime" minOccurs="0" />
<xsd:element name="magvar" type="degreesType" minOccurs="0" />
<xsd:element name="geoidheight" type="xsd:decimal" minOccurs="0" />
<xsd:element name="name" type="xsd:string" minOccurs="0" />
<xsd:element name="cmt" type="xsd:string" minOccurs="0" />
<xsd:element name="desc" type="xsd:string" minOccurs="0" />
<xsd:element name="src" type="xsd:string" minOccurs="0" />
<xsd:element name="link" type="linkType" minOccurs="0" maxOccurs="unbounded" />
<xsd:element name="sym" type="xsd:string" minOccurs="0" />
<xsd:element name="type" type="xsd:string" minOccurs="0" />
<xsd:element name="fix" type="fixType" minOccurs="0" />
<xsd:element name="sat" type="xsd:nonNegativeInteger" minOccurs="0" />
<xsd:element name="hdop" type="xsd:decimal" minOccurs="0" />
<xsd:element name="vdop" type="xsd:decimal" minOccurs="0" />
<xsd:element name="pdop" type="xsd:decimal" minOccurs="0" />
<xsd:element name="ageofdgpsdata" type="xsd:decimal" minOccurs="0" />
<xsd:element name="dgpsid" type="dgpsStationType" minOccurs="0" />
<xsd:element name="extensions" type="extensionsType" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="lat" type="latitudeType" use="required" />
<xsd:attribute name="lon" type="longitudeType" use="required" />
</xsd:complexType>
<xsd:simpleType name="latitudeType">
<xsd:restriction base="xsd:decimal">
<xsd:minInclusive value="-90.0"/>
<xsd:maxInclusive value="90.0"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="longitudeType">
<xsd:restriction base="xsd:decimal">
<xsd:minInclusive value="-180.0"/>
<xsd:maxExclusive value="180.0"/>
</xsd:restriction>
</xsd:simpleType>
*/
Q_ASSERT(m_reader->isStartElement()
&& (m_reader->name() == elementName));
QGeoCoordinate coord;
if (m_reader->attributes().hasAttribute("lat")) {
bool ok = false;
QString s = m_reader->attributes().value("lat").toString();
if ((s == "INF") || (s == "-INF") || (s == "NaN")) {
m_reader->raiseError(QString("The attribute \"lat\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
double lat = s.toDouble(&ok);
if (!ok) {
m_reader->raiseError(QString("The attribute \"lat\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
if (lat < -90.0 || 90.0 < lat) {
m_reader->raiseError(QString("The attribute \"lat\" fell outside of the bounds -90.0 <= lat <= 90.0 (value was \"%1\").").arg(s));
return false;
}
coord.setLatitude(lat);
} else {
m_reader->raiseError(QString("The element \"%1\" did not have the required attribute \"lat\".").arg(elementName));
return false;
}
if (m_reader->attributes().hasAttribute("lon")) {
bool ok = false;
QString s = m_reader->attributes().value("lon").toString();
if ((s == "INF") || (s == "-INF") || (s == "NaN")) {
m_reader->raiseError(QString("The attribute \"lon\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
double lon = s.toDouble(&ok);
if (!ok) {
m_reader->raiseError(QString("The attribute \"lon\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
if (lon < -180.0 || 180.0 <= lon) {
m_reader->raiseError(QString("The attribute \"lon\" fell outside of the bounds -180.0 <= lat < 180.0 (value was \"%1\").").arg(s));
return false;
}
coord.setLongitude(lon);
} else {
m_reader->raiseError(QString("The element \"%1\" did not have the required attribute \"lon\".").arg(elementName));
return false;
}
landmark.setCoordinate(coord);
if (!m_reader->readNextStartElement())
return true;
if (m_reader->name() == "ele") {
bool ok = false;
QString s = m_reader->readElementText();
if ((s == "INF") || (s == "-INF") || (s == "NaN")) {
m_reader->raiseError(QString("The element \"ele\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
double alt = s.toDouble(&ok);
if (!ok) {
m_reader->raiseError(QString("The element \"ele\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
coord.setAltitude(alt);
landmark.setCoordinate(coord);
if (!m_reader->readNextStartElement())
return true;
}
QList<QString> unusedNames1;
unusedNames1 << "time";
unusedNames1 << "magvar";
unusedNames1 << "geoidheight";
for (int i = 0; i < unusedNames1.size(); ++i) {
if (m_reader->name() == unusedNames1.at(i)) {
// Not used outside of schema compliance check
m_reader->skipCurrentElement();
if (!m_reader->readNextStartElement())
return true;
}
}
if (m_reader->name() == "name") {
landmark.setName(m_reader->readElementText());
if (!m_reader->readNextStartElement())
return true;
}
if (m_reader->name() == "cmt") {
// Not used outside of schema compliance check
m_reader->skipCurrentElement();
if (!m_reader->readNextStartElement())
return true;
}
if (m_reader->name() == "desc") {
landmark.setDescription(m_reader->readElementText());
if (!m_reader->readNextStartElement())
return true;
}
if (m_reader->name() == "src") {
// Not used outside of schema compliance check
m_reader->skipCurrentElement();
if (!m_reader->readNextStartElement())
return true;
}
while (m_reader->name() == "link") {
// Not used outside of schema compliance check
m_reader->skipCurrentElement();
if (!m_reader->readNextStartElement())
return true;
}
QList<QString> unusedNames2;
unusedNames2 << "sym";
unusedNames2 << "type";
unusedNames2 << "fix";
unusedNames2 << "sat";
unusedNames2 << "hdop";
unusedNames2 << "vdop";
unusedNames2 << "pdop";
unusedNames2 << "ageofdgpsdata";
unusedNames2 << "dgpsid";
unusedNames2 << "extensions";
for (int i = 0; i < unusedNames2.size(); ++i) {
if (m_reader->name() == unusedNames2.at(i)) {
// Not used outside of schema compliance check
m_reader->skipCurrentElement();
if (!m_reader->readNextStartElement())
return true;
}
}
m_reader->raiseError(QString("The element \"%1\" did not expect a child element named \"%2\" at this point (unknown child element or child element out of order).").arg(elementName).arg(m_reader->name().toString()));
return false;
}
QGeoPositionInfo LiblocationWrapper::lastKnownPosition(bool fromSatellitePositioningMethodsOnly) const
{
QGeoPositionInfo posInfo;
QGeoCoordinate coordinate;
double time;
double latitude;
double longitude;
double altitude;
double speed;
double track;
double climb;
GConfItem lastKnownPositionTime("/system/nokia/location/lastknown/time");
GConfItem lastKnownPositionLatitude("/system/nokia/location/lastknown/latitude");
GConfItem lastKnownPositionLongitude("/system/nokia/location/lastknown/longitude");
GConfItem lastKnownPositionAltitude("/system/nokia/location/lastknown/altitude");
GConfItem lastKnownPositionSpeed("/system/nokia/location/lastknown/speed");
GConfItem lastKnownPositionTrack("/system/nokia/location/lastknown/track");
GConfItem lastKnownPositionClimb("/system/nokia/location/lastknown/climb");
if (validLastSatUpdate)
return lastSatUpdate;
if (!fromSatellitePositioningMethodsOnly)
if (validLastUpdate)
return lastUpdate;
time = lastKnownPositionTime.value().toDouble();
latitude = lastKnownPositionLatitude.value().toDouble();
longitude = lastKnownPositionLongitude.value().toDouble();
altitude = lastKnownPositionAltitude.value().toDouble();
speed = lastKnownPositionSpeed.value().toDouble();
track = lastKnownPositionTrack.value().toDouble();
climb = lastKnownPositionClimb.value().toDouble();
if (longitude && latitude) {
coordinate.setLongitude(longitude);
coordinate.setLatitude(latitude);
if (altitude) {
coordinate.setAltitude(altitude);
}
posInfo.setCoordinate(coordinate);
}
if (speed) {
posInfo.setAttribute(QGeoPositionInfo::GroundSpeed, speed);
}
if (track) {
posInfo.setAttribute(QGeoPositionInfo::Direction, track);
}
if (climb) {
posInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, climb);
}
// Only positions with time (3D) are provided.
if (time) {
posInfo.setTimestamp(QDateTime::fromTime_t(time));
return posInfo;
}
return QGeoPositionInfo();
}
void LiblocationWrapper::locationChanged(LocationGPSDevice *device,
gpointer data)
{
QGeoPositionInfo posInfo;
QGeoCoordinate coordinate;
QGeoSatelliteInfo satInfo;
int satellitesInUseCount = 0;
LiblocationWrapper *object;
if (!data || !device) {
return;
}
object = (LiblocationWrapper *)data;
if (device) {
if (device->fix) {
if (device->fix->fields & LOCATION_GPS_DEVICE_TIME_SET) {
posInfo.setTimestamp(QDateTime::fromTime_t(device->fix->time));
}
if (device->fix->fields & LOCATION_GPS_DEVICE_LATLONG_SET) {
coordinate.setLatitude(device->fix->latitude);
coordinate.setLongitude(device->fix->longitude);
posInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy,
device->fix->eph / 100.0);
posInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy,
device->fix->epv);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_ALTITUDE_SET) {
coordinate.setAltitude(device->fix->altitude);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_SPEED_SET) {
posInfo.setAttribute(QGeoPositionInfo::GroundSpeed,
device->fix->speed / 3.6);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_CLIMB_SET) {
posInfo.setAttribute(QGeoPositionInfo::VerticalSpeed,
device->fix->climb);
}
if (device->fix->fields & LOCATION_GPS_DEVICE_TRACK_SET) {
posInfo.setAttribute(QGeoPositionInfo::Direction,
device->fix->track);
}
}
if (device->satellites_in_view) {
QList<QGeoSatelliteInfo> satsInView;
QList<QGeoSatelliteInfo> satsInUse;
unsigned int i;
for (i = 0;i < device->satellites->len;i++) {
LocationGPSDeviceSatellite *satData =
(LocationGPSDeviceSatellite *)g_ptr_array_index(device->satellites,
i);
satInfo.setSignalStrength(satData->signal_strength);
satInfo.setPrnNumber(satData->prn);
satInfo.setAttribute(QGeoSatelliteInfo::Elevation,
satData->elevation);
satInfo.setAttribute(QGeoSatelliteInfo::Azimuth,
satData->azimuth);
satsInView.append(satInfo);
if (satData->in_use) {
satellitesInUseCount++;
satsInUse.append(satInfo);
}
}
if (!satsInView.isEmpty())
object->satellitesInViewUpdated(satsInView);
if (!satsInUse.isEmpty())
object->satellitesInUseUpdated(satsInUse);
}
}
posInfo.setCoordinate(coordinate);
emit object->positionUpdated(posInfo);
}
void PsyUtils::TPositionInfo2QGeoPositionInfo(TPositionInfoBase &aPosInfoBase, QGeoPositionInfo& aQPosInfo)
{
if (aPosInfoBase.PositionClassType() & EPositionInfoClass ||
aPosInfoBase.PositionClassType() & EPositionSatelliteInfoClass) {
TPositionInfo *posInfo = static_cast<TPositionInfo*>(&aPosInfoBase);
TPosition pos;
QGeoCoordinate coord;
posInfo->GetPosition(pos);
coord.setLatitude(pos.Latitude());
coord.setLongitude(pos.Longitude());
coord.setAltitude(pos.Altitude());
//store the QGeoCoordinate values
aQPosInfo.setCoordinate(coord);
TDateTime datetime = pos.Time().DateTime();
QDateTime dt(QDate(datetime.Year() , datetime.Month() + 1, datetime.Day() + 1),
QTime(datetime.Hour() , datetime.Minute(), datetime.Second(),
datetime.MicroSecond() / 1000),
Qt::UTC);
//store the time stamp
aQPosInfo.setTimestamp(dt);
//store the horizontal accuracy
aQPosInfo.setAttribute(QGeoPositionInfo::HorizontalAccuracy, pos.HorizontalAccuracy());
//store the vertical accuracy
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalAccuracy, pos.VerticalAccuracy());
if (aPosInfoBase.PositionClassType() & EPositionSatelliteInfoClass) {
TCourse course;
TPositionSatelliteInfo *satInfo = static_cast<TPositionSatelliteInfo*>(&aPosInfoBase);
satInfo->GetCourse(course);
aQPosInfo.setAttribute(QGeoPositionInfo::Direction, course.Heading());
aQPosInfo.setAttribute(QGeoPositionInfo::GroundSpeed, course.Speed());
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, course.VerticalSpeed());
}
}
if (aPosInfoBase.PositionClassType() & EPositionGenericInfoClass) {
HPositionGenericInfo *genInfo = static_cast<HPositionGenericInfo*>(&aPosInfoBase);
float val;
//check for the horizontal speed
if (genInfo->IsFieldAvailable(EPositionFieldHorizontalSpeed)) {
genInfo->GetValue(EPositionFieldHorizontalSpeed, val);
aQPosInfo.setAttribute(QGeoPositionInfo::GroundSpeed, val);
}
//check for the vertcal speed
if (genInfo->IsFieldAvailable(EPositionFieldVerticalSpeed)) {
genInfo->GetValue(EPositionFieldVerticalSpeed, val);
aQPosInfo.setAttribute(QGeoPositionInfo::VerticalSpeed, val);
}
//check for the magnetic variation
if (genInfo->IsFieldAvailable(EPositionFieldMagneticCourseError)) {
genInfo->GetValue(EPositionFieldMagneticCourseError, val);
aQPosInfo.setAttribute(QGeoPositionInfo::MagneticVariation, val);
}
//check for the heading
if (genInfo->IsFieldAvailable(EPositionFieldHeading)) {
genInfo->GetValue(EPositionFieldHeading, val);
aQPosInfo.setAttribute(QGeoPositionInfo::Direction, val);
}
}
}
bool QLandmarkFileHandlerLmx::readCoordinates(QLandmark &landmark)
{
/*
<xsd:complexType name="coordinatesType">
<xsd:sequence>
<xsd:element name="latitude">
<xsd:simpleType>
<xsd:restriction base="xsd:double">
<xsd:minInclusive value="-90"/>
<xsd:maxInclusive value="90"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="longitude">
<xsd:simpleType>
<xsd:restriction base="xsd:double">
<xsd:minInclusive value="-180"/>
<xsd:maxExclusive value="180"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="altitude" type="xsd:float" minOccurs="0" />
<xsd:element name="horizontalAccuracy" minOccurs="0">
<xsd:simpleType>
<xsd:restriction base="xsd:float">
<xsd:minInclusive value="0"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="verticalAccuracy" minOccurs="0">
<xsd:simpleType>
<xsd:restriction base="xsd:float">
<xsd:minInclusive value="0"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="timeStamp" type="xsd:dateTime" minOccurs="0" />
</xsd:sequence>
</xsd:complexType>
*/
Q_ASSERT(m_reader->isStartElement() &&
(m_reader->name() == "coordinates"));
if (!m_reader->readNextStartElement()) {
m_reader->raiseError("The element \"coordinates\" did not have the required child element \"latitude\".");
return false;
}
if (m_reader->name() == "latitude") {
bool ok = false;
QString s = m_reader->readElementText();
if ((s == "INF") || (s == "-INF") || (s == "NaN")) {
m_reader->raiseError(QString("The element \"latitude\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
double lat = s.toDouble(&ok);
if (!ok) {
m_reader->raiseError(QString("The element \"latitude\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
if (lat < -90.0 || 90.0 < lat) {
m_reader->raiseError(QString("The element \"latitude\" fell outside of the bounds -90.0 <= latitude <= 90.0 (value was \"%1\").").arg(s));
return false;
}
QGeoCoordinate coord = landmark.coordinate();
coord.setLatitude(lat);
landmark.setCoordinate(coord);
if (!m_reader->readNextStartElement()) {
m_reader->raiseError("The element \"coordinates\" did not have the required child element \"longitude\".");
return false;
}
} else {
m_reader->raiseError("The element \"coordinates\" did not have the required child element \"latitude\".");
return false;
}
if (m_reader->name() == "longitude") {
bool ok = false;
QString s = m_reader->readElementText();
if ((s == "INF") || (s == "-INF") || (s == "NaN")) {
m_reader->raiseError(QString("The element \"longitude\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
double lon = s.toDouble(&ok);
if (!ok) {
m_reader->raiseError(QString("The element \"longitude\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
if (lon < -180.0 || 180.0 <= lon) {
m_reader->raiseError(QString("The element \"longitude\" fell outside of the bounds -180.0 <= longitude < 180.0 (value was \"%1\").").arg(s));
return false;
}
QGeoCoordinate coord = landmark.coordinate();
coord.setLongitude(lon);
landmark.setCoordinate(coord);
if (!m_reader->readNextStartElement())
return true;
} else {
m_reader->raiseError("The element \"coordinates\" did not have the required child element \"longitude\".");
return false;
}
if (m_reader->name() == "altitude") {
bool ok = false;
QString s = m_reader->readElementText();
if ((s == "INF") || (s == "-INF") || (s == "NaN")) {
m_reader->raiseError(QString("The element \"altitude\" expected a value convertable to type double (value was \"%1\").").arg(s));
return false;
}
double alt = s.toDouble(&ok);
if (!ok) {
m_reader->raiseError(QString("The element \"altitude\" expected a value convertable to type float (value was \"%1\").").arg(s));
return false;
}
QGeoCoordinate coord = landmark.coordinate();
coord.setAltitude(alt);
landmark.setCoordinate(coord);
if (!m_reader->readNextStartElement())
return true;
}
QList<QString> names;
names << "horizontalAccuracy";
names << "verticalAccuracy";
names << "timeStamp";
for (int i = 0; i < names.size(); ++i) {
// Not used outside of schema compliance check
if (m_reader->name() == names.at(i)) {
m_reader->skipCurrentElement();
if (!m_reader->readNextStartElement())
return true;
}
}
m_reader->raiseError(QString("The element \"coordinate\" did not expect a child element named \"%1\" at this point (unknown child element or child element out of order).").arg(m_reader->name().toString()));
return false;
}
