[Feature] Dawarich GPS retrieval

[arne182]

I have searched the existing feature requests to make sure this is not a duplicate request.

• Yes

The feature

Dawarich a Google timeline alternative could be used to give the photos a GPS location. I imagine that if a GPS point is within +-30 minutes of the photo creation then either an interpolated or a snap to the nearest point could be done so that we can see where the photo was taken.

Platform

• Server
• Web
• Mobile

[danieldietzler]

The idea is interesting. How would you map dawarich users to Immich users? Just because Immich user A is in Europe does not mean all uploaded assets from all users belong to that location.

[arne182]

They should both have the same email address but I would do it the same way that dawarich connects to immich in that you specify an API key in your profile.

[bo0tzz]

We're unlikely to add support in the Immich core for third party tools like this, but I think it'll be a great fit for a plugin once we have support for those.

[arne182]

I have finished my implementation of this feature

def fetch_pictures(date):
    headers = {"x-api-key": API_KEY}
    body = {
        "takenAfter": f"{date}T00:00:00.000Z",
        "takenBefore": f"{date}T23:59:59.999Z",
        "size": 1000,
        "withExif": True,
    }
    response = requests.post(IMMICH_URL, headers=headers, json=body)
    response.raise_for_status()
    return response.json()["assets"]["items"]

# Function to fetch geolocation data from PostgreSQL
def fetch_geolocation(timestamp):
    connection = psycopg2.connect(
        host=DB_HOST,
        port=DB_PORT,
        database=DB_NAME,
        user=DB_USER,
        password=DB_PASSWORD
    )
    cursor = connection.cursor()
    # Convert the timestamp to Unix epoch format
    timestamp_unix = int(timestamp.timestamp())
    start_time_unix = timestamp_unix - 3600  # One hour before
    end_time_unix = timestamp_unix + 3600   # One hour after
    query = f"""
        WITH points_within_hour AS (
            SELECT latitude, longitude, timestamp
            FROM points
            WHERE user_id = 2 AND timestamp BETWEEN {start_time_unix} AND {end_time_unix}
        )
        SELECT 
            ROUND(COALESCE(
                CASE WHEN timestamp - prev_timestamp = 0 THEN latitude ELSE
                (latitude - prev_latitude) * 
                ({timestamp_unix} - prev_timestamp) / 
                (timestamp - prev_timestamp) + prev_latitude END, 
                latitude
            ),6) AS interpolated_latitude,
            ROUND(COALESCE(
                CASE WHEN timestamp - prev_timestamp = 0 THEN longitude ELSE
                (longitude - prev_longitude) * 
                ({timestamp_unix} - prev_timestamp) / 
                (timestamp - prev_timestamp) + prev_longitude END, 
                longitude
            ),6) AS interpolated_longitude
        FROM (
            SELECT *, 
                   LAG(latitude) OVER (ORDER BY timestamp) AS prev_latitude,
                   LAG(longitude) OVER (ORDER BY timestamp) AS prev_longitude,
                   LAG(timestamp) OVER (ORDER BY timestamp) AS prev_timestamp
            FROM points_within_hour
        ) subquery
        WHERE {timestamp_unix} BETWEEN prev_timestamp AND timestamp;
    """
    cursor.execute(query)
    result = cursor.fetchone()
    cursor.close()
    connection.close()
    if result:
        # Ensure values are converted to float for JSON serialization
        return float(result[0]), float(result[1])
    return None

# Main function to process images
def process_images(start_date, end_date):
    current_date = datetime.strptime(start_date, "%Y-%m-%d")
    end_date = datetime.strptime(end_date, "%Y-%m-%d")
    while current_date <= end_date:
        pictures = fetch_pictures(current_date.strftime("%Y-%m-%d"))
        for picture in pictures:
            exif_info = picture.get("exifInfo", {})
            if exif_info.get("latitude") is None or exif_info.get("longitude") is None:
                timestamp = datetime.strptime(picture["fileCreatedAt"], "%Y-%m-%dT%H:%M:%S.%fZ")
                geolocation = fetch_geolocation(timestamp)
                if geolocation:
                    latitude, longitude = geolocation
                    print(f"Name: {picture['originalPath']}  {picture['fileCreatedAt']} Picture ID: {picture['id']} - Updated Latitude: {latitude}, Longitude: {longitude}")
                    # Send updated geolocation back to Immich server
                    update_payload = {
                        "ids": [picture["id"]],
                        "latitude": latitude,
                        "longitude": longitude
                    }
                    update_url = IMMICH_URL_UPDATE
                    update_headers = {"x-api-key": API_KEY}
                    update_response = requests.put(update_url, headers=update_headers, json=update_payload)
                    update_response.raise_for_status()
        current_date += timedelta(days=1)

# Example usage
process_images("2024-01-01", "2024-12-31")

[Baloe2000]

This feature would be amazing actually. I have been looking for a way to automate this somehow in self hosted applications for a long time. The implementation has been made, is there some way i can use this yet? Or should we wait for plugins to be supported?