void SearchResultModelHelper::snapItemsTo(const QModelIndex& targetIndex, const QList<QModelIndex>& snappedIndices)
{
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
SearchResultModel::SearchResultItem targetItem = d->model->resultItem(targetIndex);
const KMap::GeoCoordinates& targetCoordinates = targetItem.result.coordinates;
for (int i=0; i<snappedIndices.count(); ++i)
{
const QPersistentModelIndex itemIndex = snappedIndices.at(i);
KipiImageItem* const item = d->imageModel->itemFromIndex(itemIndex);
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(item);
GPSDataContainer newData;
newData.setCoordinates(targetCoordinates);
item->setGPSData(newData);
undoInfo.readNewDataFromItem(item);
undoCommand->addUndoInfo(undoInfo);
}
undoCommand->setText(i18np("1 image snapped to '%2'",
"%1 images snapped to '%2'", snappedIndices.count(), targetItem.result.name));
emit(signalUndoCommand(undoCommand));
}
void SearchWidget::slotMoveSelectedImagesToThisResult()
{
const QModelIndex currentIndex = d->searchResultsSelectionModel->currentIndex();
const SearchResultModel::SearchResultItem currentItem = d->searchResultsModel->resultItem(currentIndex);
const KMap::GeoCoordinates& targetCoordinates = currentItem.result.coordinates;
const QModelIndexList selectedImageIndices = d->kipiImageSelectionModel->selectedRows();
if (selectedImageIndices.isEmpty())
return;
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
for (int i=0; i<selectedImageIndices.count(); ++i)
{
const QPersistentModelIndex itemIndex = selectedImageIndices.at(i);
KipiImageItem* const item = d->kipiImageModel->itemFromIndex(itemIndex);
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(item);
GPSDataContainer newData;
newData.setCoordinates(targetCoordinates);
item->setGPSData(newData);
undoInfo.readNewDataFromItem(item);
undoCommand->addUndoInfo(undoInfo);
}
undoCommand->setText(i18np("1 image moved to '%2'",
"%1 images moved to '%2'", selectedImageIndices.count(), currentItem.result.name));
emit(signalUndoCommand(undoCommand));
}
void GPSBookmarkOwner::openBookmark(const KBookmark& bookmark, Qt::MouseButtons, Qt::KeyboardModifiers)
{
const QString url = bookmark.url().url().toLower();
bool okay = false;
const GeoIface::GeoCoordinates coordinate = GeoIface::GeoCoordinates::fromGeoUrl(url, &okay);
if (okay)
{
GPSDataContainer position;
position.setCoordinates(coordinate);
emit(positionSelected(position));
}
}
void GPSSyncKGeoMapModelHelper::onIndicesMoved(const QList<QPersistentModelIndex>& movedMarkers,
const GeoCoordinates& targetCoordinates,
const QPersistentModelIndex& targetSnapIndex)
{
if (targetSnapIndex.isValid())
{
const QAbstractItemModel* const targetModel = targetSnapIndex.model();
for (int i=0; i<d->ungroupedModelHelpers.count(); ++i)
{
ModelHelper* const ungroupedHelper = d->ungroupedModelHelpers.at(i);
if (ungroupedHelper->model()==targetModel)
{
QList<QModelIndex> iMovedMarkers;
for (int i=0; i<movedMarkers.count(); ++i)
{
iMovedMarkers << movedMarkers.at(i);
}
ungroupedHelper->snapItemsTo(targetSnapIndex, iMovedMarkers);
return;
}
}
}
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
for (int i=0; i<movedMarkers.count(); ++i)
{
const QPersistentModelIndex itemIndex = movedMarkers.at(i);
KipiImageItem* const item = static_cast<KipiImageItem*>(d->model->itemFromIndex(itemIndex));
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(item);
GPSDataContainer newData;
newData.setCoordinates(targetCoordinates);
item->setGPSData(newData);
undoInfo.readNewDataFromItem(item);
undoCommand->addUndoInfo(undoInfo);
}
undoCommand->setText(i18np("1 image moved",
"%1 images moved", movedMarkers.count()));
emit(signalUndoCommand(undoCommand));
}
void GPSCorrelatorWidget::slotItemsCorrelated(const Digikam::TrackCorrelator::Correlation::List& correlatedItems)
{
qCDebug(DIGIKAM_GENERAL_LOG) << correlatedItems.count();
d->correlationTriedCount += correlatedItems.count();
for (int i = 0; i < correlatedItems.count(); ++i)
{
const TrackCorrelator::Correlation& itemCorrelation = correlatedItems.at(i);
const QPersistentModelIndex itemIndex = itemCorrelation.userData.value<QPersistentModelIndex>();
if (!itemIndex.isValid())
continue;
GPSImageItem* const imageItem = d->imageModel->itemFromIndex(itemIndex);
if (!imageItem)
continue;
if (itemCorrelation.flags&TrackCorrelator::CorrelationFlagCoordinates)
{
d->correlationCorrelatedCount++;
GPSDataContainer newData;
newData.setCoordinates(itemCorrelation.coordinates);
if (itemCorrelation.nSatellites >= 0)
newData.setNSatellites(itemCorrelation.nSatellites);
// if hDop is available, use it
if (itemCorrelation.hDop >= 0)
newData.setDop(itemCorrelation.hDop);
// but if pDop is available, prefer pDop over hDop
if (itemCorrelation.pDop >= 0)
newData.setDop(itemCorrelation.pDop);
if (itemCorrelation.fixType >= 0)
{
newData.setFixType(itemCorrelation.fixType);
}
if (itemCorrelation.speed >= 0)
{
newData.setSpeed(itemCorrelation.speed);
}
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(imageItem);
imageItem->setGPSData(newData);
undoInfo.readNewDataFromItem(imageItem);
d->correlationUndoCommand->addUndoInfo(undoInfo);
}
}
emit(signalProgressChanged(d->correlationTriedCount));
}
void GPSImageDetails::slotApply()
{
GPSDataContainer newData;
if (d->cbCoordinates->isChecked())
{
const double lat = d->leLatitude->text().toDouble();
const double lon = d->leLongitude->text().toDouble();
newData.setCoordinates(GeoIface::GeoCoordinates(lat, lon));
if (d->cbAltitude->isChecked())
{
const qreal alt = static_cast<qreal>(d->leAltitude->text().toDouble());
newData.setAltitude(alt);
}
if (d->cbSpeed->isChecked())
{
const qreal speed = static_cast<qreal>(d->leSpeed->text().toDouble());
newData.setSpeed(speed);
}
if (d->cbNSatellites->isChecked())
{
const int nSatellites = d->leNSatellites->text().toInt();
newData.setNSatellites(nSatellites);
}
if (d->cbFixType->isChecked())
{
const int fixType = d->comboFixType->itemData(d->comboFixType->currentIndex()).toInt();
newData.setFixType(fixType);
}
if (d->cbDop->isChecked())
{
const qreal dop = static_cast<qreal>(d->leDop->text().toDouble());
newData.setDop(dop);
}
}
GPSImageItem* const gpsItem = d->imageModel->itemFromIndex(d->imageIndex);
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
GPSUndoCommand::UndoInfo undoInfo(d->imageIndex);
undoInfo.readOldDataFromItem(gpsItem);
gpsItem->setGPSData(newData);
undoInfo.readNewDataFromItem(gpsItem);
undoCommand->addUndoInfo(undoInfo);
undoCommand->setText(i18n("Details changed"));
emit(signalUndoCommand(undoCommand));
}
bool GPSDataParser::matchDate(const QDateTime& photoDateTime, int maxGapTime, int timeZone,
bool interpolate, int interpolationDstTime,
GPSDataContainer& gpsData)
{
// GPS device are sync in time by satelite using GMT time.
// If the camera time is different than GMT time, we need to convert it to GMT time
// Using the time zone.
QDateTime cameraGMTDateTime = photoDateTime.addSecs(timeZone*(-1));
kDebug( 51000 ) << "cameraGMTDateTime: " << cameraGMTDateTime << endl;
// We trying to find the right date in the GPS points list.
bool findItem = false;
int nbSecItem = maxGapTime;
int nbSecs;
for (GPSDataMap::ConstIterator it = m_GPSDataMap.constBegin();
it != m_GPSDataMap.constEnd(); ++it )
{
// Here we check a possible accuracy in seconds between the
// Camera GMT time and the GPS device GMT time.
nbSecs = abs(cameraGMTDateTime.secsTo( it.key() ));
// We tring to find the minimal accuracy.
if( nbSecs < maxGapTime && nbSecs < nbSecItem)
{
gpsData = m_GPSDataMap[it.key()];
findItem = true;
nbSecItem = nbSecs;
}
}
if (findItem) return true;
// If we can't find it, we will trying to interpolate the GPS point.
if (interpolate)
{
// The interpolate GPS point will be separate by at the maximum of 'interpolationDstTime'
// seconds before and after the next and previous real GPS point found.
QDateTime prevDateTime = findPrevDate(cameraGMTDateTime, interpolationDstTime);
QDateTime nextDateTime = findNextDate(cameraGMTDateTime, interpolationDstTime);
if (!nextDateTime.isNull() && !prevDateTime.isNull())
{
GPSDataContainer prevGPSPoint = m_GPSDataMap[prevDateTime];
GPSDataContainer nextGPSPoint = m_GPSDataMap[nextDateTime];
double alt1 = prevGPSPoint.altitude();
double lon1 = prevGPSPoint.longitude();
double lat1 = prevGPSPoint.latitude();
uint t1 = prevDateTime.toTime_t();
double alt2 = nextGPSPoint.altitude();
double lon2 = nextGPSPoint.longitude();
double lat2 = nextGPSPoint.latitude();
uint t2 = nextDateTime.toTime_t();
uint tCor = cameraGMTDateTime.toTime_t();
if (tCor-t1 != 0)
{
gpsData.setAltitude(alt1 + (alt2-alt1) * (tCor-t1)/(t2-t1));
gpsData.setLatitude(lat1 + (lat2-lat1) * (tCor-t1)/(t2-t1));
gpsData.setLongitude(lon1 + (lon2-lon1) * (tCor-t1)/(t2-t1));
gpsData.setInterpolated(true);
return true;
}
}
}
return false;
}