def interpolate_with_anchors(anchors, angle_offset):
    '''
    Interpolate gps position and compass angle given a list of anchors
        anchor:
            lat: latitude
            lon: longitude
            alt: altitude
            datetime: date time of the anchor (datetime object)
            num_image: number of images in between two anchors
    '''
    points = [ (a['datetime'], a['lat'], a['lon'], a.get('alt', 0)) for a in anchors]

    inter_points = []
    for i, (a1, a2) in enumerate(zip(points[:], points[1:])):
        t1 = a1[0]
        t2 = a2[0]
        num_image = anchors[i]['num_image']
        delta = (t2-t1).total_seconds()/float(num_image+1)
        inter_points.append(points[i]+(0.0,))
        for ii in xrange(num_image):
            t = t1 + datetime.timedelta(seconds=(ii+1)*delta)
            p = interpolate_lat_lon(points, t)
            inter_points.append((t,)+p)
    inter_points.append(points[-1]+(0,0,))

    # get angles
    bearings = [offset_bearing(compute_bearing(ll1[1], ll1[2], ll2[1], ll2[2]), angle_offset)
                    for ll1, ll2 in zip(inter_points, inter_points[1:])]
    bearings.append(bearings[-1])
    inter_points = [ (p[0], p[1], p[2], p[4], bearing) for p, bearing in zip(inter_points, bearings)]

    return inter_points
Esempio n. 2
0
def add_exif_using_timestamp(filename,
                             time,
                             points,
                             offset_time=0,
                             offset_bearing=0):
    '''
    Find lat, lon and bearing of filename and write to EXIF.
    '''

    metadata = ExifEdit(filename)

    # subtract offset in s beween gpx time and exif time
    t = time - datetime.timedelta(seconds=offset_time)

    try:
        lat, lon, bearing, elevation = interpolate_lat_lon(points, t)
        corrected_bearing = (bearing + offset_bearing) % 360
        metadata.add_lat_lon(lat, lon)
        metadata.add_direction(corrected_bearing)
        if elevation is not None:
            metadata.add_altitude(elevation)
        metadata.write()
        print(
            "Added geodata to: {}  time {}  lat {}  lon {}  alt {}  bearing {}"
            .format(filename, time, lat, lon, elevation, exiv_bearing))
    except ValueError, e:
        print("Skipping {0}: {1}".format(filename, e))
Esempio n. 3
0
def add_exif_using_timestamp(filename,
                             time,
                             points,
                             offset_time=0,
                             offset_angle=0):
    '''
    Find lat, lon and bearing of filename and write to EXIF.
    '''

    metadata = pyexiv2.ImageMetadata(filename)
    metadata.read()

    # subtract offset in s beween gpx time and exif time
    t = time - datetime.timedelta(seconds=offset_time)

    try:
        lat, lon, bearing, elevation, speed = interpolate_lat_lon(points, t)

        lat_deg = decimal_to_dms(lat, ["S", "N"])
        lon_deg = decimal_to_dms(lon, ["W", "E"])

        # convert decimal coordinates into degrees, minutes and seconds as fractions for EXIF
        exiv_lat = (make_fraction(lat_deg[0],
                                  1), make_fraction(int(lat_deg[1]), 1),
                    make_fraction(int(lat_deg[2] * 1000000), 1000000))
        exiv_lon = (make_fraction(lon_deg[0],
                                  1), make_fraction(int(lon_deg[1]), 1),
                    make_fraction(int(lon_deg[2] * 1000000), 1000000))

        # convert direction into fraction
        bearing = offset_bearing(bearing, offset_angle)
        exiv_bearing = make_fraction(int(bearing * 100), 100)

        # add to exif
        metadata["Exif.GPSInfo.GPSLatitude"] = exiv_lat
        metadata["Exif.GPSInfo.GPSLatitudeRef"] = lat_deg[3]
        metadata["Exif.GPSInfo.GPSLongitude"] = exiv_lon
        metadata["Exif.GPSInfo.GPSLongitudeRef"] = lon_deg[3]
        metadata["Exif.Image.GPSTag"] = 654
        metadata["Exif.GPSInfo.GPSMapDatum"] = "WGS-84"
        metadata["Exif.GPSInfo.GPSVersionID"] = '2 0 0 0'
        metadata["Exif.GPSInfo.GPSImgDirection"] = exiv_bearing
        metadata["Exif.GPSInfo.GPSImgDirectionRef"] = "T"

        if elevation is not None:
            exiv_elevation = make_fraction(abs(int(elevation * 10)), 10)
            metadata["Exif.GPSInfo.GPSAltitude"] = exiv_elevation
            metadata[
                "Exif.GPSInfo.GPSAltitudeRef"] = '0' if elevation >= 0 else '1'

        metadata.write()
        print("Added geodata to {}: {}, {:.6f}, {:.6f}, {:.1f}".format(
            os.path.basename(filename), time, lat, lon, bearing))

        if (speed is not None and speed < 0.6):
            move_into_dir(filename, os.path.dirname(filename) + "\S0")

    except ValueError, e:
        print("Skipping {0}: {1}".format(filename, e))
Esempio n. 4
0
def add_exif_using_timestamp(filename, time, points, offset_time=0, offset_bearing=0):
    '''
    Find lat, lon and bearing of filename and write to EXIF.
    '''

    metadata = pyexiv2.ImageMetadata(filename)
    metadata.read()
    print(time)
    print(datetime.timedelta(seconds=offset_time))
    #print(points)

    
    # subtract offset in s beween gpx time and exif time
    t = time - datetime.timedelta(seconds=offset_time)

    try:
        lat, lon, bearing, elevation = interpolate_lat_lon(points, t)

        lat_deg = decimal_to_dms(lat, ["S", "N"])
        lon_deg = decimal_to_dms(lon, ["W", "E"])

        # convert decimal coordinates into degrees, minutes and seconds as fractions for EXIF
        exiv_lat = (make_fraction(lat_deg[0],1), make_fraction(int(lat_deg[1]),1), make_fraction(int(lat_deg[2]*1000000),1000000))
        exiv_lon = (make_fraction(lon_deg[0],1), make_fraction(int(lon_deg[1]),1), make_fraction(int(lon_deg[2]*1000000),1000000))

        corrected_bearing = (bearing + offset_bearing) % 360

        # convert direction into fraction
        exiv_bearing = make_fraction(int(corrected_bearing*100),100)

        # add to exif
        metadata["Exif.GPSInfo.GPSLatitude"] = exiv_lat
        metadata["Exif.GPSInfo.GPSLatitudeRef"] = lat_deg[3]
        metadata["Exif.GPSInfo.GPSLongitude"] = exiv_lon
        metadata["Exif.GPSInfo.GPSLongitudeRef"] = lon_deg[3]
        metadata["Exif.Image.GPSTag"] = 654
        metadata["Exif.GPSInfo.GPSMapDatum"] = "WGS-84"
        metadata["Exif.GPSInfo.GPSVersionID"] = '2 0 0 0'
        metadata["Exif.GPSInfo.GPSImgDirection"] = exiv_bearing
        metadata["Exif.GPSInfo.GPSImgDirectionRef"] = "T"

        if elevation is not None:
            exiv_elevation = make_fraction(abs(int(elevation*10)),10)
            metadata["Exif.GPSInfo.GPSAltitude"] = exiv_elevation
            metadata["Exif.GPSInfo.GPSAltitudeRef"] = '0' if elevation >= 0 else '1'

        metadata.write()
        print("Added geodata to: {}  time {}  lat {}  lon {}  alt {}  bearing {}".format(filename, time, lat, lon, elevation, exiv_bearing))
    except ValueError, e:
        print("Skipping {0}: {1}".format(filename, e))
Esempio n. 5
0
def geotag_from_gpx(piclists, gpx_file, offset_time=0, offset_bearings=0, offset_distance=0):
    """This function will try to find the location (lat lon) for each pictures in each list, compute the direction
    of the pictures with an offset if given, and offset the location with a distance if given. Then, these
    coordinates will be added in the New_Picture_infos namedtuple.
    :param piclists: a list of of list of New_Picture_infos namedtuple
    :param gpx_file: a gpx or nmea file path
    :param offset_time: time offset between the gpx/nmea file, and the image's timestamp
    :param offset_bearings: the offset angle to add to the direction of the images (for side camera)
    :param offset_distance: a distance (in meter) to move the image from the computed location. (Use this setting to
    not have all the images from a multicam setup at the same exact location
    :return: nothing, the function update the New_Picture_infos namedtuple inside the lists"""
    now = datetime.datetime.now(tzlocal())
    print("Your local timezone is {0}, if this is not correct, your geotags will be wrong.".format(
        now.strftime('%Y-%m-%d %H:%M:%S %z')))

    # read gpx file to get track locations
    if gpx_file.lower().endswith(".gpx"):
        gpx = get_lat_lon_time_from_gpx(gpx_file)
    elif gpx_file.lower().endswith(".nmea"):
        gpx = get_lat_lon_time_from_nmea(gpx_file)
    else:
        print("\nWrong gnss file! It should be a .gpx or .nmea file.")
        sys.exit()

    for piclist, offset_bearing in zip(piclists, offset_bearings):

        start_time = time.time()
        print("===\nStarting geotagging of {0} images using {1}.\n===".format(len(piclist), gpx_file))

        # for filepath, filetime in zip(piclist.path, piclist.New_DateTimeOriginal):
        for i, pic in enumerate(piclist):
            # add_exif_using_timestamp(filepath, filetime, gpx, time_offset, bearing_offset)
            # metadata = ExifEdit(filename)
            t = pic.New_DateTimeOriginal - datetime.timedelta(seconds=offset_time)
            try:
                lat, lon, bearing, elevation = interpolate_lat_lon(gpx, t)
                corrected_bearing = (bearing + offset_bearing) % 360
                # Apply offset to the coordinates if distance_offset exists
                if offset_distance != 0:
                    new_Coords = LatLon(lat, lon).offset(corrected_bearing, offset_distance / 1000)
                    lat = new_Coords.lat.decimal_degree
                    lon = new_Coords.lon.decimal_degree
                # Add coordinates, elevation and bearing to the New_Picture_infos namedtuple
                piclist[i] = pic._replace(Longitude=lon, Latitude=lat, Ele=elevation, ImgDirection=corrected_bearing)

            except ValueError, e:
                print("Skipping {0}: {1}".format(pic.path, e))

        print("Done geotagging {0} images in {1:.1f} seconds.".format(len(piclist), time.time() - start_time))
Esempio n. 6
0
        sample_video(video_file, image_path, sample_interval, video_type)

    # Add EXIF data to sample images
    image_list = list_images(image_path)
    print "Adding EXIF to {} images".format(len(image_list))

    missing_gps = 0
    for i, im in enumerate(image_list):
        io.progress(i, len(image_list))
        timestamp = timestamp_from_filename(os.path.basename(im),
                                            sample_interval, start_time,
                                            video_duration, time_offset,
                                            duration_ratio)

        try:
            lat, lon, bearing, altitude = geo.interpolate_lat_lon(
                points, timestamp)
            data = {
                "lat": lat,
                "lon": lon,
                "altitude": altitude,
                "capture_time": timestamp,
                "bearing": (bearing + args.offset_angle) % 360,
                "make": make,
                "model": model
            }
            exifedit.add_exif_data(os.path.join(image_path, im), data)
        except Exception as e:
            print "Image {} timestamp out of range. Skipping".format(im)
            missing_gps += 1

    print "{} image samples with {} images missing gps".format(
    # Add EXIF data to sample images
    image_list = list_images(image_path)
    print "Adding EXIF to {} images".format(len(image_list))

    missing_gps = 0
    for i, im in enumerate(image_list):
        io.progress(i, len(image_list))
        timestamp = timestamp_from_filename(os.path.basename(im),
                                            sample_interval,
                                            start_time,
                                            video_duration,
                                            time_offset)

        try:
            lat, lon, bearing, altitude = geo.interpolate_lat_lon(points, timestamp)
            data = {
                "lat": lat,
                "lon": lon,
                "altitude": altitude,
                "capture_time": timestamp,
                "bearing": bearing,
                "make": make,
                "model": model
            }
            exifedit.add_exif_data(os.path.join(image_path, im), data)
        except Exception as e:
            print e
            print "Image {} timestamp out of range. Skipping".format(im)
            missing_gps += 1