Find the average latitute and longitude at each destination

This code processes Google Timeline data to identify and categorize destinations by finding nearby geographical locations associated with each timeline entry. It then calculates average coordinates for these destinations and filters out entries that are not relevant.

Run example

What the code could have been:

const { readFileSync } = require('fs');
const _ = require('underscore');
const core = require('../Core');

const PROFILE_PATH = process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
const PROJECT_PATH = PROFILE_PATH + '/Timeline';

/**
 * Converts degrees to radians.
 * @param {number} angle Angle in degrees.
 * @returns {number} Angle in radians.
 */
function toRadians(angle) {
    return angle * (Math.PI / 180);
}

/**
 * Calculates the straight distance between two points on the Earth's surface.
 * @param {number} lat1 Latitude of the first point.
 * @param {number} lon1 Longitude of the first point.
 * @param {number} lat2 Latitude of the second point.
 * @param {number} lon2 Longitude of the second point.
 * @returns {number} Distance in meters.
 */
function straightDistance(lat1, lon1, lat2, lon2) {
    const R = 6371e3; // metres
    const φ1 = toRadians(lat1);
    const φ2 = toRadians(lat2);
    const Δφ = toRadians(lat2 - lat1);
    const Δλ = toRadians(lon2 - lon1);

    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
        Math.cos(φ1) * Math.cos(φ2) *
        Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

    const d = R * c;
    return d;
}

/**
 * Calculates the average destination based on the nearest locations.
 * @param {object[]} geoLocations Geolocation data.
 * @param {object[]} timelineLocations Timeline locations.
 * @returns {object[]} Destinations with average locations.
 */
function averageDestinations(geoLocations, timelineLocations) {
    const destinations = [];

    // Remove driving locations and filter nearby locations
    const filteredTimelineLocations = timelineLocations.filter(d => d.name!== '' && d.name.indexOf('Driving') === -1);

    for (const d of filteredTimelineLocations) {
        const nearest = _.sortBy(
            geoLocations,
            l => Math.abs(new Date(l.time).getTime() - new Date(d.time).getTime())
        ).slice(0, 3);

        // Check if the nearest locations are not too far
        if (!nearest.some(n => straightDistance(
            n.latitudeE7 / 10000000,
            n.longitudeE7 / 10000000,
            nearest[0].latitudeE7 / 10000000,
            nearest[0].longitudeE7 / 10000000
        ) < 2000)) {
            console.log(`Too far! ${d.name} - ${d.time}`);
            console.log(nearest.map(n => straightDistance(
                n.latitudeE7 / 10000000,
                n.longitudeE7 / 10000000,
                nearest[0].latitudeE7 / 10000000,
                nearest[0].longitudeE7 / 10000000
            )));
            continue;
        }

        // Calculate average location
        const averageLat = nearest.map(n => n.latitudeE7).reduce((a, b) => a + b, 0) / nearest.length / 10000000;
        const averageLon = nearest.map(n => n.longitudeE7).reduce((a, b) => a + b, 0) / nearest.length / 10000000;

        const locations = nearest.map(n => ({
           ...n,
            averageLat: n.latitudeE7 - averageLat,
            averageLon: n.longitudeE7 - averageLon,
            averageDist: straightDistance(
                n.latitudeE7 / 10000000,
                n.longitudeE7 / 10000000,
                averageLat,
                averageLon
            )
        }));

        destinations.push({
           ...d,
            averageLat,
            averageLon,
            locations
        });
    }

    return destinations;
}

module.exports = averageDestinations;

This code analyzes Google Timeline data to identify and categorize destinations.