add X- fields to supported tags wasm

Author: thisisaaronland

cmd/tags-supported-wasm/main.go

@@ -20,9 +20,18 @@ func main() {
 			log.Printf("Failed to derive supported tags, %v", err)
 			return nil
 		}
-
+		
 		sort.Strings(tags_supported)
 
+		x_tags := []string{
+			"X-Latitude",
+			"X-Longitude",
+		}
+
+		for _, t := range x_tags {
+			tags_supported = append(tags_supported, t)
+		}
+		
 		enc_supported, err := json.Marshal(tags_supported)
 
 		if err != nil {

cmd/update-exif-wasm/main.go

@@ -100,7 +100,7 @@ func UpdateFunc() js.Func {
 				var buf bytes.Buffer
 				img_wr := bufio.NewWriter(&buf)
 
-				err = update.UpdateExif(img_fh, img_wr, exif_data)
+				err = update.PrepareAndUpdateExif(img_fh, img_wr, exif_data)
 
 				if err != nil {
 					reject.Invoke(fmt.Printf("Failed update EXIF properties, %v", err))

cmd/update-exif/main.go

@@ -8,13 +8,17 @@ import (
 	"github.com/sfomuseum/go-flags/multi"
 	"log"
 	"os"
+	"strings"
 )
 
 func main() {
 
 	var properties multi.KeyValueString
 	flag.Var(&properties, "property", "One or more {TAG}={VALUE} EXIF properties. {TAG} must be a recognized EXIF tag.")
 
+	lat := flag.Float64("latitude", 0.0, "")
+	lon := flag.Float64("longitude", 0.0, "")
+
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, "Command-line tool for updating the EXIF properties in one or more JPEG images. Images are not updated in place but written to STDOUT.\n\n")
 		fmt.Fprintf(os.Stderr, "Usage:\n\t%s [options] image(N) image(N) image(N)\n\n", os.Args[0])
@@ -32,19 +36,31 @@ func main() {
 		k := p.Key()
 		v := p.Value().(string)
 
-		ok, err := tags.IsSupported(k)
+		if !strings.HasPrefix(k, "X-") {
 
-		if err != nil {
-			log.Fatalf("Failed to determine whether tag '%s' is supported, %v", k, err)
-		}
+			ok, err := tags.IsSupported(k)
 
-		if !ok {
-			log.Fatalf("Tag '%s' is not supported by this tool, at this time", k)
+			if err != nil {
+				log.Fatalf("Failed to determine whether tag '%s' is supported, %v", k, err)
+			}
+
+			if !ok {
+				log.Fatalf("Tag '%s' is not supported by this tool, at this time", k)
+			}
 		}
 
 		exif_props[k] = v
 	}
 
+	if *lat != 0.0 && *lon != 0.0 {
+
+		err := update.AppendGPSPropertiesWithLatitudeAndLongitude(exif_props, *lat, *lon)
+
+		if err != nil {
+			log.Fatalf("Failed to append latitude and longitude properties, %v", err)
+		}
+	}
+
 	for _, path := range paths {
 
 		fh, err := os.Open(path)
@@ -55,7 +71,7 @@ func main() {
 
 		defer fh.Close()
 
-		err = update.UpdateExif(fh, os.Stdout, exif_props)
+		err = update.PrepareAndUpdateExif(fh, os.Stdout, exif_props)
 
 		if err != nil {
 			log.Fatalf("Failed to update '%s', %v", path, err)

gps.go

@@ -0,0 +1,39 @@
+package update
+
+import (
+	"fmt"
+)
+
+func AppendGPSPropertiesWithLatitudeAndLongitude(exif_props map[string]interface{}, lat float64, lon float64) error {
+
+	gps_lat, err := PrepareDecimalGPSLatitudeTag(lat)
+
+	if err != nil {
+		return fmt.Errorf("Failed to prepare GPSLatitudeTag, %v", err)
+	}
+
+	gps_lat_ref, err := PrepareDecimalGPSLatitudeRefTag(lat)
+
+	if err != nil {
+		return fmt.Errorf("Failed to prepare GPSLatitudeRefTag, %v", err)
+	}
+
+	gps_lon, err := PrepareDecimalGPSLongitudeTag(lon)
+
+	if err != nil {
+		return fmt.Errorf("Failed to prepare GPSLatitudeTag, %v", err)
+	}
+
+	gps_lon_ref, err := PrepareDecimalGPSLongitudeRefTag(lon)
+
+	if err != nil {
+		return fmt.Errorf("Failed to prepare GPSLatitudeRefTag, %v", err)
+	}
+
+	exif_props["GPSLatitude"] = gps_lat
+	exif_props["GPSLatitudeRef"] = gps_lat_ref
+	exif_props["GPSLongitude"] = gps_lon
+	exif_props["GPSLongitudeRef"] = gps_lon_ref
+
+	return nil
+}

gps_test.go

@@ -0,0 +1,19 @@
+package update
+
+import (
+	"testing"
+)
+
+func TestAppendGPSPropertiesWithLatitudeAndLongitude(t *testing.T) {
+
+	lat := 37.61799
+	lon := -122.384864
+
+	props := make(map[string]interface{})
+
+	err := AppendGPSPropertiesWithLatitudeAndLongitude(props, lat, lon)
+
+	if err != nil {
+		t.Fatalf("Failed to append GPS properties, %v", err)
+	}
+}

prepare.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"github.com/dsoprea/go-exif/v3"
 	"github.com/dsoprea/go-exif/v3/common"
-	"log"
+	_ "log"
 	"math"
 )
 
@@ -100,8 +100,6 @@ func PrepareTag(k string, v string) (interface{}, error) {
 			return nil, err
 		}
 
-		log.Println("WTF", k, v, v2)
-
 		// https://github.com/dsoprea/go-exif/blob/db167117f4830a268022c953f0f521fcc83d031e/v3/common/value_encoder.go#L225
 
 		switch v2.(type) {

update.go

@@ -9,6 +9,7 @@ import (
 	"github.com/sfomuseum/go-exif-update/tags"
 	"io"
 	_ "log"
+	"strconv"
 )
 
 var ti *exif.TagIndex
@@ -31,9 +32,94 @@ func init() {
 
 }
 
-// UpdateExif updates the EXIF data encoded in r and writes that data to wr.
+// PrepareAndUpdateExif attempts to prepare and translate EXIF properties in defined in exif_props
+// in to their appropriate dsoprea/go-exif types and format and then updates the EXIF data encoded in
+// r and writes that data to wr. This method also supports a handful of custom properties that are
+// prefixed with X- and used to populate known EXIF properties. These are:
+// * X-Latitude and X-Longitude, which convert and assign decimal latitude and longitude coordinates
+//   in to their GPSLatitude/Longitude and GPSLatitude/LongitudeRef EXIF properties.
+func PrepareAndUpdateExif(r io.Reader, wr io.Writer, exif_props map[string]interface{}) error {
+
+	prepared := make(map[string]interface{})
+
+	var lat float64
+	var lon float64
+
+	x_lat, has_lat := exif_props["X-Latitude"]
+	x_lon, has_lon := exif_props["X-Longitude"]
+
+	if has_lat && !has_lon {
+		return fmt.Errorf("Missing X-Longitude property (X-Latitude is set)")
+	}
+
+	if has_lon && !has_lat {
+		return fmt.Errorf("Missing X-Latitude property (X-Longitude is set)")
+	}
+
+	if has_lat && has_lon {
+
+		switch x_lat.(type) {
+		case float64:
+			lat = x_lat.(float64)
+		case string:
+
+			l, err := strconv.ParseFloat(x_lat.(string), 64)
+
+			if err != nil {
+				return err
+			}
+
+			lat = l
+		default:
+			return fmt.Errorf("Invalid type for latitude, %T", lat)
+		}
+
+		switch x_lon.(type) {
+		case float64:
+			lon = x_lon.(float64)
+		case string:
+
+			l, err := strconv.ParseFloat(x_lon.(string), 64)
+
+			if err != nil {
+				return err
+			}
+
+			lon = l
+
+		default:
+			return fmt.Errorf("Invalid type for longitude")
+		}
+
+		err := AppendGPSPropertiesWithLatitudeAndLongitude(prepared, lat, lon)
+
+		if err != nil {
+			return err
+		}
+
+		delete(exif_props, "X-Latitude")
+		delete(exif_props, "X-Longitude")
+	}
+
+	for k, v := range exif_props {
+
+		str_v := fmt.Sprintf("%v", v)
+		v2, err := PrepareTag(k, str_v)
+
+		if err != nil {
+			return fmt.Errorf("Failed to prepare tag '%s', %v", k, err)
+		}
+
+		prepared[k] = v2
+	}
+
+	return UpdateExif(r, wr, prepared)
+}
+
 // This is really nothing more than a thin wrapper around the example code in
 // dsoprea's go-jpeg-image-structure package.
+
+// UpdateExif updates the EXIF data encoded in r and writes that data to wr.
 func UpdateExif(r io.Reader, wr io.Writer, exif_props map[string]interface{}) error {
 
 	img_data, err := io.ReadAll(r)