From 12bb30e9d25703a50f114229273bf9fa4db4de98 Mon Sep 17 00:00:00 2001
From: cleme <cleme@LAPTOP-7CJ3VMUM.fulpmes.lanthaler.cc>
Date: Tue, 4 Jan 2022 13:30:28 +0100
Subject: [PATCH] Changing of GPS information is now possible Added custom GPS
 information during export is now possible to overwrite possible information
 from the mediafile

---
 PhotoSlide/pom.xml                            |   9 +
 .../photoslide/ExportDialogController.java    | 128 ++++++-
 .../org/photoslide/MainViewController.java    |  18 +-
 .../browsermetadata/BoundingArea.java         |  98 ++++++
 .../browsermetadata/Coordinate.java           |  89 +++++
 .../browsermetadata/DMSCoordinate.java        |  71 ++++
 .../browsermetadata/DegreeCoordinate.java     |  59 ++++
 .../photoslide/browsermetadata/EarthCalc.java | 304 +++++++++++++++++
 .../browsermetadata/GPSCoordinate.java        |  44 +++
 .../photoslide/browsermetadata/GeoCoding.java | 154 +++++++++
 .../browsermetadata/MetadataController.java   | 311 ++++++++++++++----
 .../org/photoslide/browsermetadata/Point.java |  72 ++++
 .../browsermetadata/RadianCoordinate.java     |  53 +++
 .../org/photoslide/datamodel/MediaFile.java   | 151 +++++++--
 .../org/photoslide/fxml/BrowserMetadata.fxml  |  15 +-
 .../org/photoslide/fxml/ExportDialog.fxml     |  36 +-
 16 files changed, 1495 insertions(+), 117 deletions(-)
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/BoundingArea.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/Coordinate.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/DMSCoordinate.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/DegreeCoordinate.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/EarthCalc.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/GPSCoordinate.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/GeoCoding.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/Point.java
 create mode 100644 PhotoSlide/src/main/java/org/photoslide/browsermetadata/RadianCoordinate.java

diff --git a/PhotoSlide/pom.xml b/PhotoSlide/pom.xml
index aea5cf9..37ca5fc 100644
--- a/PhotoSlide/pom.xml
+++ b/PhotoSlide/pom.xml
@@ -68,6 +68,10 @@
         <repository>
             <id>OpenIMAJ maven releases repository</id>
             <url>https://maven.openimaj.org</url>
+        </repository>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
         </repository>        
     </repositories>                        
     
@@ -220,6 +224,11 @@
             <artifactId>faces</artifactId>
             <version>1.3.10</version>
         </dependency>
+        <dependency>
+            <groupId>fr.dudie</groupId>
+            <artifactId>nominatim-api</artifactId>
+            <version>3.4</version>
+        </dependency>
 
         <!-- This downloads the platform specific JavaFX libraries used by the project. -->
         <!-- For the final installable, the JavaFX dependencies are provided via modules, but by including these here
diff --git a/PhotoSlide/src/main/java/org/photoslide/ExportDialogController.java b/PhotoSlide/src/main/java/org/photoslide/ExportDialogController.java
index a89ddad..403f041 100644
--- a/PhotoSlide/src/main/java/org/photoslide/ExportDialogController.java
+++ b/PhotoSlide/src/main/java/org/photoslide/ExportDialogController.java
@@ -5,12 +5,18 @@
  */
 package org.photoslide;
 
+import com.sothawo.mapjfx.Coordinate;
+import com.sothawo.mapjfx.MapType;
+import com.sothawo.mapjfx.MapView;
+import com.sothawo.mapjfx.Marker;
 import java.io.File;
 import java.net.URL;
 import java.util.Collection;
 import java.util.ResourceBundle;
 import javafx.beans.binding.Bindings;
 import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.concurrent.Task;
 import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.fxml.Initializable;
@@ -18,15 +24,23 @@
 import javafx.scene.control.CheckBox;
 import javafx.scene.control.ComboBox;
 import javafx.scene.control.Label;
+import javafx.scene.control.ProgressIndicator;
 import javafx.scene.control.Slider;
 import javafx.scene.control.TextField;
 import javafx.scene.control.Tooltip;
+import javafx.scene.effect.ColorAdjust;
 import javafx.scene.input.KeyCode;
 import javafx.scene.input.KeyEvent;
 import javafx.scene.layout.FlowPane;
+import javafx.scene.layout.VBox;
 import javafx.stage.DirectoryChooser;
 import javafx.stage.Stage;
 import javafx.util.Duration;
+import org.controlsfx.control.textfield.AutoCompletionBinding;
+import org.controlsfx.control.textfield.CustomTextField;
+import org.controlsfx.control.textfield.TextFields;
+import org.kordamp.ikonli.javafx.FontIcon;
+import org.photoslide.browsermetadata.GeoCoding;
 import org.photoslide.browsermetadata.Tag;
 
 /**
@@ -76,6 +90,20 @@ public class ExportDialogController implements Initializable {
     private TextField titleTextBox;
     @FXML
     private Button plusButton;
+    @FXML
+    private CheckBox replaceGPSCheckBox;
+    @FXML
+    private MapView mapView;
+    private GeoCoding geoCoding;
+    @FXML
+    private CustomTextField customField;
+    @FXML
+    private Button searchButton;
+    private Marker markerPos;
+    @FXML
+    private VBox mapSelectionPane;
+    @FXML
+    private CustomTextField heightTextField;
 
     @Override
     public void initialize(URL url, ResourceBundle rb) {
@@ -160,7 +188,24 @@ public void initialize(URL url, ResourceBundle rb) {
                 addKeywordTextField.setDisable(true);
             }
         });
+        replaceGPSCheckBox.setOnAction((t) -> {
+            if (replaceGPSCheckBox.isSelected()) {
+                mapSelectionPane.setDisable(false);
+            } else {
+                mapSelectionPane.setDisable(true);
+            }
+        });
         keywordList = FXCollections.observableArrayList();
+        geoCoding = new GeoCoding();
+        customField.setRight(new FontIcon("ti-close"));
+        mapView.setMapType(MapType.OSM);
+        mapView.setPrefSize(350, 90);
+        mapView.setMaxSize(350, 90);
+        mapView.initialize();
+        Coordinate c = new Coordinate(48.135125, 11.581981);
+        mapView.setCenter(c);
+        markerPos = new Marker(getClass().getResource("/org/photoslide/img/map_marker.png"), -16, -32);
+        mapView.setEffect(new ColorAdjust(0, -0.5, 0, 0));
     }
 
     @FXML
@@ -225,8 +270,8 @@ private void addKeywordAction(KeyEvent event) {
         if (event.getCode() == KeyCode.ENTER) {
             keywordText.getChildren().add(new Tag(addKeywordTextField.getText()));
             addKeywordTextField.clear();
-            event.consume();
         }
+        event.consume();
     }
 
     public Collection<String> getKeywordList() {
@@ -264,4 +309,85 @@ private void plusButtonAction(ActionEvent event) {
         addKeywordTextField.clear();
     }
 
+    @FXML
+    private void searchButtonAction(ActionEvent event) {
+        String name = customField.getText();
+
+        Task<ObservableList<String>> task = new Task<>() {
+            @Override
+            protected ObservableList<String> call() throws Exception {
+                return geoCoding.geoSearchForNameAsStrings(name);
+            }
+        };
+        task.setOnScheduled((t) -> {
+            ProgressIndicator ind = new ProgressIndicator();
+            ind.setPrefSize(10, 10);
+            ind.setMinSize(10, 10);
+            ind.setMaxSize(10, 10);
+            customField.setRight(ind);
+        });
+        task.setOnSucceeded((t) -> {
+            customField.setRight(null);
+            ObservableList<String> geoSearchForNameAsStrings = (ObservableList<String>) t.getSource().getValue();
+            //set autocomplete
+            AutoCompletionBinding<String> autoComp = TextFields.bindAutoCompletion(customField, geoSearchForNameAsStrings);
+            customField.setText(geoSearchForNameAsStrings.get(0));
+            customField.requestFocus();
+            autoComp.setUserInput(name);
+            autoComp.setOnAutoCompleted((o) -> {
+                int index = geoSearchForNameAsStrings.indexOf(customField.getText());
+                if (index == -1) {
+                    index = 0;
+                }
+                geoCoding.setLastSearchGPSResult(geoCoding.getLastSearchResult().get(index));
+                Coordinate c = new Coordinate(geoCoding.getLastSearchResult().get(index).getLatitude(), geoCoding.getLastSearchResult().get(index).getLongitude());
+                mapView.setCenter(c);
+                markerPos.setPosition(c).setVisible(true);
+                mapView.addMarker(markerPos);
+            });
+        });
+        task.setOnFailed((t) -> {
+            customField.setRight(null);
+        });
+        new Thread(task).start();
+    }
+
+    @FXML
+    private void searchTFPressed(KeyEvent event) {
+        if (event.getCode() == KeyCode.ENTER) {
+            searchButtonAction(null);
+        }
+        event.consume();
+    }
+
+    public CheckBox getReplaceGPSCheckBox() {
+        return replaceGPSCheckBox;
+    }
+    
+    public String getSelectedGPSPos(){
+        if (replaceGPSCheckBox.isSelected()){
+            return geoCoding.getLastSearchGPSResult().getLatitude()+";"+geoCoding.getLastSearchGPSResult().getLongitude();
+        }
+        return "";
+    }
+    
+    public double getSelectedGPSPosLat(){
+        if (replaceGPSCheckBox.isSelected()){
+            return geoCoding.getLastSearchGPSResult().getLatitude();
+        }
+        return -1;
+    }
+    
+    public double getSelectedGPSPosLon(){
+        if (replaceGPSCheckBox.isSelected()){
+            return geoCoding.getLastSearchGPSResult().getLongitude();
+        }
+        return -1;
+    }
+
+    public CustomTextField getHeightTextField() {
+        return heightTextField;
+    }
+    
+
 }
diff --git a/PhotoSlide/src/main/java/org/photoslide/MainViewController.java b/PhotoSlide/src/main/java/org/photoslide/MainViewController.java
index dc98d2b..04d98bb 100644
--- a/PhotoSlide/src/main/java/org/photoslide/MainViewController.java
+++ b/PhotoSlide/src/main/java/org/photoslide/MainViewController.java
@@ -91,6 +91,7 @@
 import org.kordamp.ikonli.javafx.FontIcon;
 import org.photoslide.bookmarksboard.BMBIcon;
 import org.photoslide.bookmarksboard.BookmarkBoardController;
+import org.photoslide.browsermetadata.GeoCoding;
 import org.photoslide.datamodel.FileTypes;
 import org.photoslide.editormedia.EditorMediaViewController;
 import org.photoslide.editormetadata.EditorMetadataController;
@@ -374,7 +375,6 @@ protected Boolean call() throws Exception {
                                         break;
                                 }
                                 String outFileStr;
-                                System.out.println("Option: " + diag.getController().getFilename());
                                 if (diag.getController().getFilename().equalsIgnoreCase("<Original>_")) {
                                     outFileStr = outputDir + File.separator + mediaItem.getName() + (i + 1) + "." + imageType.getExtension();
                                 } else {
@@ -457,7 +457,13 @@ protected Boolean call() throws Exception {
                                     if (diag.getController().getReplaceKeywordChoiceBox().isSelected()) {
                                         mediaItem.setKeywords(diag.getController().getKeywordsAsString());
                                     }
-                                    metadataPaneController.exportCompleteMetdata(mediaItem, outFileStr, imageType.getExtension());
+                                    if (diag.getController().getReplaceGPSCheckBox().isSelected()) {
+                                        if (!diag.getController().getHeightTextField().getText().equalsIgnoreCase("")) {
+                                            mediaItem.setGpsHeight(Double.parseDouble(diag.getController().getHeightTextField().getText()));
+                                        }
+                                        mediaItem.setGpsPositionFromDegree(diag.getController().getSelectedGPSPos());
+                                    }
+                                    metadataPaneController.exportCompleteMetdata(mediaItem, outFileStr, imageType.getExtension(), diag.getController().getReplaceGPSCheckBox().isSelected());
                                 }
                                 if (diag.getController().getExportBasicMetadataBox().isSelected()) {
                                     metadataPaneController.readBasicMetadata(this, mediaItem);
@@ -467,7 +473,13 @@ protected Boolean call() throws Exception {
                                     if (diag.getController().getReplaceKeywordChoiceBox().isSelected()) {
                                         mediaItem.setKeywords(diag.getController().getKeywordsAsString());
                                     }
-                                    metadataPaneController.exportBasicMetadata(mediaItem, outFileStr);
+                                    if (!diag.getController().getHeightTextField().getText().equalsIgnoreCase("")) {
+                                        mediaItem.setGpsHeight(Double.parseDouble(diag.getController().getHeightTextField().getText()));
+                                    }
+                                    if (diag.getController().getReplaceGPSCheckBox().isSelected()) {
+                                        mediaItem.setGpsPositionFromDegree(diag.getController().getSelectedGPSPos());
+                                    }
+                                    metadataPaneController.exportBasicMetadata(mediaItem, outFileStr, diag.getController().getReplaceGPSCheckBox().isSelected());
                                 }
                             } catch (FileNotFoundException ex) {
                                 Logger.getLogger(MainViewController.class.getName()).log(Level.SEVERE, null, ex);
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/BoundingArea.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/BoundingArea.java
new file mode 100644
index 0000000..551490e
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/BoundingArea.java
@@ -0,0 +1,98 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+
+
+/**
+ * Represents an area (rectangular shape projected onto Earth), defined by its top left and bottom right
+ * coordinates.
+ * <p>
+ * Allows for fast geo-spatial search of all points within this rectangular area.
+ */
+public class BoundingArea {
+    public final Point northEast, southWest;
+    public final Point southEast, northWest;
+
+    private BoundingArea(Point northEast, Point southWest) {
+        this.northEast = northEast;
+        this.southWest = southWest;
+
+        southEast = Point.at(Coordinate.fromDegrees(southWest.latitude), Coordinate.fromDegrees(northEast.longitude));
+        northWest = Point.at(Coordinate.fromDegrees(northEast.latitude), Coordinate.fromDegrees(southWest.longitude));
+    }
+
+    public static BoundingArea at(Point northEast, Point southWest) {
+        return new BoundingArea(northEast, southWest);
+    }
+
+    @Override
+    public String toString() {
+        return "BoundingArea{" + "northEast=" + northEast + ", southWest=" + southWest + '}';
+    }
+
+    /**
+     * @return true if Point point is contained withing this bounding area
+     * @deprecated use contains(Point point)
+     */
+    @Deprecated
+    public boolean isContainedWithin(Point point) {
+        return contains(point);
+    }
+
+    /**
+     * @param point point to check
+     * @return true if Point point is contained withing this bounding area
+     */
+    public boolean contains(Point point) {
+        boolean predicate1 = point.latitude >= this.southWest.latitude && point.latitude <= this.northEast.latitude;
+
+        if (!predicate1) {
+            return false;
+        }
+
+        boolean predicate2;
+
+        if (southWest.longitude > northEast.longitude) { //area is going across the max/min longitude boundaries (ie. sort of back of the Earth)
+            //we "split" the area in 2, longitude-wise, point only needs to be in one or the other.
+            boolean predicate3 = point.longitude <= northEast.longitude && point.longitude >= -180;
+            boolean predicate4 = point.longitude >= southWest.longitude && point.longitude <= 180;
+
+            predicate2 = predicate3 || predicate4;
+        } else {
+            predicate2 = point.longitude >= southWest.longitude && point.longitude <= northEast.longitude;
+        }
+
+        return predicate2;
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/Coordinate.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/Coordinate.java
new file mode 100644
index 0000000..b3ed9d5
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/Coordinate.java
@@ -0,0 +1,89 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+import static java.lang.Math.*;
+
+/**
+ * Abstraction of coordinate systems (degrees, radians, dms and gps)
+ */
+abstract public class Coordinate implements Serializable {
+
+    abstract double degrees();
+
+    public static DegreeCoordinate fromDegrees(double decimalDegrees) {
+        return new DegreeCoordinate(decimalDegrees);
+    }
+
+    public static DMSCoordinate fromDMS(double wholeDegrees, double minutes, double seconds) {
+        return new DMSCoordinate(wholeDegrees, minutes, seconds);
+    }
+
+    public static GPSCoordinate fromGPS(double wholeDegrees, double minutes) {
+        return new GPSCoordinate(wholeDegrees, minutes);
+    }
+
+    public static RadianCoordinate fromRadians(double radians) {
+        return new RadianCoordinate(radians);
+    }
+
+    public DMSCoordinate toDMSCoordinate() {
+        int wholeDegrees = (int) degrees();
+        var remaining = abs(degrees() - wholeDegrees);
+        int minutes = (int) (remaining * 60);
+        remaining = remaining * 60 - minutes;
+        double seconds = new BigDecimal(remaining * 60).setScale(4, RoundingMode.HALF_UP).doubleValue();
+
+        return new DMSCoordinate(wholeDegrees, minutes, seconds);
+    }
+
+    public DegreeCoordinate toDegreeCoordinate() {
+        return new DegreeCoordinate(degrees());
+    }
+
+    public GPSCoordinate toGPSCoordinate() {
+        double wholeDegrees = floor(degrees());
+        double remaining = degrees() - wholeDegrees;
+        double minutes = floor(remaining * 60);
+
+        return new GPSCoordinate(wholeDegrees, minutes);
+    }
+
+    public RadianCoordinate toRadianCoordinate() {
+        return new RadianCoordinate(toRadians(degrees()));
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/DMSCoordinate.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/DMSCoordinate.java
new file mode 100644
index 0000000..44004cf
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/DMSCoordinate.java
@@ -0,0 +1,71 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+
+import static java.lang.Math.abs;
+
+/**
+ * Represents coordinates given in
+ * Degrees Minutes decimal-seconds (D M s) format
+ */
+public class DMSCoordinate extends Coordinate {
+
+    public final double wholeDegrees, minutes, seconds;
+
+    public DMSCoordinate(double wholeDegrees, double minutes, double seconds) {
+        this.wholeDegrees = wholeDegrees;
+        this.minutes = minutes;
+        this.seconds = seconds;
+    }
+
+    @Override
+    double degrees() {
+        var decimalDegrees = abs(wholeDegrees) + minutes / 60 + seconds / 3600;
+
+        if (wholeDegrees < 0) {
+            decimalDegrees = -decimalDegrees;
+        }
+
+        return decimalDegrees;
+    }
+
+    @Override
+    public String toString() {
+        return "DMSCoordinate{" +
+                "wholeDegrees=" + wholeDegrees +
+                ", minutes=" + minutes +
+                ", seconds=" + seconds +
+                '}';
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/DegreeCoordinate.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/DegreeCoordinate.java
new file mode 100644
index 0000000..571082c
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/DegreeCoordinate.java
@@ -0,0 +1,59 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+
+/**
+ * Represents coordinates given in
+ * decimal-degrees (d) format
+ */
+public class DegreeCoordinate extends Coordinate {
+
+    public final double decimalDegrees;
+
+    public DegreeCoordinate(double decimalDegrees) {
+        this.decimalDegrees = decimalDegrees;
+    }
+    
+    
+
+    @Override
+    double degrees() {
+        return decimalDegrees;
+    }
+
+    @Override
+    public String toString() {
+        return "DegreeCoordinate{" + "decimalDegrees=" + decimalDegrees + " degrees}";
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/EarthCalc.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/EarthCalc.java
new file mode 100644
index 0000000..abbb77a
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/EarthCalc.java
@@ -0,0 +1,304 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+import static java.lang.Math.*;
+
+/**
+ * Earth related calculations.
+ */
+public class EarthCalc {
+
+    public static final double EARTH_RADIUS = 6_356_752.314245D; // radius at the poles, meters
+
+    public static class gcd {
+        /**
+         * This is the half-way point along a great circle path between the two points.
+         *
+         * @param standPoint standPoint
+         * @param forePoint  standPoint
+         * @return mid point
+         * @see <a href="http://www.movable-type.co.uk/scripts/latlong.html"></a>
+         */
+        public static Point midPoint(Point standPoint, Point forePoint) {
+            double λ1 = toRadians(standPoint.longitude);
+            double λ2 = toRadians(forePoint.longitude);
+
+            double φ1 = toRadians(standPoint.latitude);
+            double φ2 = toRadians(forePoint.latitude);
+
+            double Bx = cos(φ2) * cos(λ2 - λ1);
+            double By = cos(φ2) * sin(λ2 - λ1);
+
+            double φ3 = atan2(sin(φ1) + sin(φ2), sqrt((cos(φ1) + Bx) * (cos(φ1) + Bx) + By * By));
+            double λ3 = λ1 + atan2(By, cos(φ1) + Bx);
+
+            return Point.at(Coordinate.fromRadians(φ3), Coordinate.fromRadians(λ3));
+        }
+
+        /**
+         * Returns the distance between two points at spherical law of cosines.
+         *
+         * @param standPoint The stand point
+         * @param forePoint  The fore point
+         * @return The distance, in meters
+         */
+        public static double distance(Point standPoint, Point forePoint) {
+
+            double Δλ = toRadians(abs(forePoint.longitude - standPoint.longitude));
+            double φ1 = toRadians(standPoint.latitude);
+            double φ2 = toRadians(forePoint.latitude);
+
+            //spherical law of cosines
+            double sphereCos = (sin(φ1) * sin(φ2)) + (cos(φ1) * cos(φ2) * cos(Δλ));
+            double c = acos(max(min(sphereCos, 1d), -1d));
+
+            return EARTH_RADIUS * c;
+        }
+
+        /**
+         * Returns the coordinates of a point which is "distance" away
+         * from standPoint in the direction of "bearing"
+         * <p>
+         * Note: North is equal to 0 for bearing value
+         *
+         * @param standPoint Origin
+         * @param bearing    Direction in degrees, clockwise from north
+         * @param distance   distance in meters
+         * @return forePoint coordinates
+         * @see <a href="http://www.movable-type.co.uk/scripts/latlong.html"></a>
+         */
+        public static Point pointAt(Point standPoint, double bearing, double distance) {
+        /*
+         φ2 = asin( sin φ1 ⋅ cos δ + cos φ1 ⋅ sin δ ⋅ cos θ )
+         λ2 = λ1 + atan2( sin θ ⋅ sin δ ⋅ cos φ1, cos δ − sin φ1 ⋅ sin φ2 )
+
+         where
+         φ is latitude,
+         λ is longitude,
+         θ is the bearing (clockwise from north),
+         δ is the angular distance d/R;
+         d being the distance travelled, R the earth’s radius
+         */
+
+            double φ1 = toRadians(standPoint.latitude);
+            double λ1 = toRadians(standPoint.longitude);
+            double θ = toRadians(bearing);
+            double δ = distance / EARTH_RADIUS; // normalize linear distance to radian angle
+
+            double φ2 = asin(sin(φ1) * cos(δ) + cos(φ1) * sin(δ) * cos(θ));
+            double λ2 = λ1 + atan2(sin(θ) * sin(δ) * cos(φ1), cos(δ) - sin(φ1) * sin(φ2));
+
+            double λ2_harmonised = (λ2 + 3 * PI) % (2 * PI) - PI; // normalise to −180..+180°
+
+            return Point.at(Coordinate.fromRadians(φ2), Coordinate.fromRadians(λ2_harmonised));
+        }
+
+        /**
+         * Returns the (azimuth) bearing, in decimal degrees, from standPoint to forePoint
+         *
+         * @param standPoint Origin point
+         * @param forePoint  Destination point
+         * @return (azimuth) bearing, in decimal degrees
+         */
+        public static double bearing(Point standPoint, Point forePoint) {
+            /*
+             * Formula: θ = atan2( 	sin(Δlong).cos(lat2), cos(lat1).sin(lat2) − sin(lat1).cos(lat2).cos(Δlong) )
+             */
+            double Δlong = toRadians(forePoint.longitude - standPoint.longitude);
+            double y = sin(Δlong) * cos(toRadians(forePoint.latitude));
+            double x = cos(toRadians(standPoint.latitude)) * sin(toRadians(forePoint.latitude))
+                    - sin(toRadians(standPoint.latitude)) * cos(toRadians(forePoint.latitude)) * cos(Δlong);
+
+            double bearing = (atan2(y, x) + 2 * PI) % (2 * PI);
+
+            return toDegrees(bearing);
+        }
+
+        /**
+         * Returns an area around standPoint
+         *
+         * @param standPoint The centre of the area
+         * @param distance   Distance around standPoint, im meters
+         * @return The area
+         * @see <a href="http://www.movable-type.co.uk/scripts/latlong.html"></a>
+         */
+        public static BoundingArea around(Point standPoint, double distance) {
+
+            //45 degrees going north-east
+            Point northEast = pointAt(standPoint, 45, distance);
+
+            //225 degrees going south-west
+            Point southWest = pointAt(standPoint, 225, distance);
+
+            return BoundingArea.at(northEast, southWest);
+        }
+    }
+
+    public static class haversine {
+        /**
+         * Returns the distance between two points at Haversine formula.
+         *
+         * @param standPoint The stand point
+         * @param forePoint  The fore point
+         * @return The distance, in meters
+         */
+        public static double distance(Point standPoint, Point forePoint) {
+
+            double Δλ = toRadians(abs(forePoint.longitude - standPoint.longitude));
+            double φ1 = toRadians(standPoint.latitude);
+            double φ2 = toRadians(forePoint.latitude);
+
+            // haversine formula
+            double Δφ = toRadians(abs(forePoint.latitude - standPoint.latitude));
+            double a = sin(Δφ / 2) * sin(Δφ / 2) + cos(φ1) * cos(φ2) * sin(Δλ / 2) * sin(Δλ / 2);
+            double c = 2 * atan2(sqrt(a), sqrt(1 - a)); //angular distance in radians
+
+            return EARTH_RADIUS * c;
+        }
+    }
+
+    public static class vincenty {
+        /**
+         * Calculate distance, (azimuth) bearing and final bearing between standPoint and forePoint.
+         *
+         * @param standPoint The stand point
+         * @param forePoint  The fore point
+         * @return Vincenty object which holds all 3 values
+         */
+        private static Vincenty vincenty(Point standPoint, Point forePoint) {
+            double λ1 = toRadians(standPoint.longitude);
+            double λ2 = toRadians(forePoint.longitude);
+
+            double φ1 = toRadians(standPoint.latitude);
+            double φ2 = toRadians(forePoint.latitude);
+
+            double a = 6_378_137D; // radius at equator
+            double b = EARTH_RADIUS; // Using b to keep close to academic formula.
+            double f = 1 / 298.257223563D; // flattening of the ellipsoid
+
+            double L = λ2 - λ1;
+            double tanU1 = (1 - f) * tan(φ1);
+            double cosU1 = 1 / sqrt((1 + tanU1 * tanU1));
+            double sinU1 = tanU1 * cosU1;
+
+            double tanU2 = (1 - f) * tan(φ2);
+            double cosU2 = 1 / sqrt((1 + tanU2 * tanU2));
+            double sinU2 = tanU2 * cosU2;
+
+            double λ = L, λʹ, iterationLimit = 100, cosSqα, σ, cos2σM, cosσ, sinσ, sinλ, cosλ;
+            do {
+                sinλ = sin(λ);
+                cosλ = cos(λ);
+                double sinSqσ = (cosU2 * sinλ) * (cosU2 * sinλ) + (cosU1 * sinU2 - sinU1 * cosU2 * cosλ) * (cosU1 * sinU2 - sinU1 * cosU2 * cosλ);
+                sinσ = sqrt(sinSqσ);
+                if (sinσ == 0) return Vincenty.CO_INCIDENT_POINTS;  // co-incident points
+                cosσ = sinU1 * sinU2 + cosU1 * cosU2 * cosλ;
+                σ = atan2(sinσ, cosσ);
+                double sinα = cosU1 * cosU2 * sinλ / sinσ;
+                cosSqα = 1 - sinα * sinα;
+                cos2σM = cosσ - 2 * sinU1 * sinU2 / cosSqα;
+
+                if (Double.isNaN(cos2σM)) cos2σM = 0;  // equatorial line: cosSqα=0
+                double C = f / 16 * cosSqα * (4 + f * (4 - 3 * cosSqα));
+                λʹ = λ;
+                λ = L + (1 - C) * f * sinα * (σ + C * sinσ * (cos2σM + C * cosσ * (-1 + 2 * cos2σM * cos2σM)));
+            } while (abs(λ - λʹ) > 1e-12 && --iterationLimit > 0);
+
+            if (iterationLimit == 0) throw new IllegalStateException("Formula failed to converge");
+
+            double uSq = cosSqα * (a * a - b * b) / (b * b);
+            double A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+            double B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+            double Δσ = B * sinσ * (cos2σM + B / 4 * (cosσ * (-1 + 2 * cos2σM * cos2σM) -
+                    B / 6 * cos2σM * (-3 + 4 * sinσ * sinσ) * (-3 + 4 * cos2σM * cos2σM)));
+
+            double distance = b * A * (σ - Δσ);
+
+            var initialBearing = atan2(cosU2 * sinλ, cosU1 * sinU2 - sinU1 * cosU2 * cosλ);
+            initialBearing = (initialBearing + 2 * PI) % (2 * PI); //turning value to trigonometric direction
+
+            var finalBearing = atan2(cosU1 * sinλ, -sinU1 * cosU2 + cosU1 * sinU2 * cosλ);
+            finalBearing = (finalBearing + 2 * PI) % (2 * PI);  //turning value to trigonometric direction
+
+            return new Vincenty(distance, toDegrees(initialBearing), toDegrees(finalBearing));
+        }
+
+        public static double distance(Point standPoint, Point forePoint) {
+            return vincenty(standPoint, forePoint).distance;
+        }
+
+        /**
+         * Returns (azimuth) bearing at Vincenty formula.
+         *
+         * @param standPoint The stand point
+         * @param forePoint  The fore point
+         * @return (azimuth) bearing in degrees to the North
+         * @see <a href="http://www.movable-type.co.uk/scripts/latlong.html"></a>
+         */
+        public static double bearing(Point standPoint, Point forePoint) {
+            return vincenty(standPoint, forePoint).initialBearing;
+        }
+
+        /**
+         * Returns final bearing in direction of standPoint→forePoint at Vincenty formula.
+         *
+         * @param standPoint The stand point
+         * @param forePoint  The fore point
+         * @return (azimuth) bearing in degrees to the North
+         * @see <a href="http://www.movable-type.co.uk/scripts/latlong.html"></a>
+         */
+        public static double finalBearing(Point standPoint, Point forePoint) {
+            return vincenty(standPoint, forePoint).finalBearing;
+        }
+
+        private static class Vincenty {
+            final static Vincenty CO_INCIDENT_POINTS = new Vincenty(0, 0, 0);
+
+            /**
+             * distance is the distance in meter
+             * initialBearing is the initial bearing, or forward azimuth (in reference to North point), in degrees
+             * finalBearing is the final bearing (in direction p1→p2), in degrees
+             */
+            final double distance, initialBearing, finalBearing;
+
+            public Vincenty(double distance, double initialBearing, double finalBearing) {
+                this.distance = distance;
+                this.initialBearing = initialBearing;
+                this.finalBearing = finalBearing;
+            }
+
+            
+        }
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/GPSCoordinate.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/GPSCoordinate.java
new file mode 100644
index 0000000..d1b2925
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/GPSCoordinate.java
@@ -0,0 +1,44 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+/**
+ * Represents coordinates given in
+ * Degrees decimal-minutes (D m) format
+ */
+public class GPSCoordinate extends DMSCoordinate {
+
+    GPSCoordinate(double wholeDegrees, double minutes) {
+        super(wholeDegrees, minutes, 0);
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/GeoCoding.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/GeoCoding.java
new file mode 100644
index 0000000..a37a3fb
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/GeoCoding.java
@@ -0,0 +1,154 @@
+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package org.photoslide.browsermetadata;
+
+import fr.dudie.nominatim.client.JsonNominatimClient;
+import fr.dudie.nominatim.model.Address;
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javax.net.ssl.SSLContext;
+import org.apache.http.config.Registry;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.conn.HttpClientConnectionManager;
+import org.apache.http.conn.socket.ConnectionSocketFactory;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
+import org.apache.http.ssl.SSLContexts;
+import org.photoslide.ExportDialogController;
+
+/**
+ *
+ * @author cleme
+ */
+public class GeoCoding {
+
+    private final String baseUrl = "https://nominatim.openstreetmap.org";
+    private final String email = "clemens.lanthaler@itarchitects.at";
+    private JsonNominatimClient nominatimClient;
+    private List<Address> lastSearchResult;
+    private Address lastSearchGPSResult;
+
+    public GeoCoding() {
+        HttpClientBuilder builder = HttpClientBuilder.create();
+        SSLContext context = SSLContexts.createDefault();
+        SSLConnectionSocketFactory sslConnectionFactory = new SSLConnectionSocketFactory(context, NoopHostnameVerifier.INSTANCE);
+        builder.setSSLSocketFactory(sslConnectionFactory);
+
+        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
+                .register("https", sslConnectionFactory)
+                .build();
+
+        HttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(registry);
+
+        builder.setConnectionManager(ccm);
+        CloseableHttpClient httpClient = builder.build();
+        nominatimClient = new JsonNominatimClient(baseUrl, httpClient, email);
+    }
+
+    /**
+     *
+     * @param name the name to search for e.g. a city, street, ...
+     * @return a list of all found addresses. The first address matches at most.
+     * The name is stored in displayname property
+     */
+    public ObservableList<Address> geoSearchForNameAsAddress(String name) {
+        if (name == null) {
+            return FXCollections.emptyObservableList();
+        }
+        if (name.equalsIgnoreCase("")) {
+            return FXCollections.emptyObservableList();
+        }
+        try {
+            //final Address address = nominatimClient.getAddress(1.64891269513038, 48.1166561643464);
+            final List<Address> addresses = nominatimClient.search(name);
+            return FXCollections.observableArrayList(addresses);
+        } catch (IOException ex) {
+            Logger.getLogger(ExportDialogController.class.getName()).log(Level.SEVERE, null, ex);
+            return FXCollections.emptyObservableList();
+        }
+    }
+
+    public ObservableList<String> geoSearchForNameAsStrings(String name) {
+        if (name == null) {
+            return FXCollections.emptyObservableList();
+        }
+        if (name.equalsIgnoreCase("")) {
+            return FXCollections.emptyObservableList();
+        }
+        ObservableList<String> retList = FXCollections.observableArrayList();
+        try {
+            //final Address address = nominatimClient.getAddress(1.64891269513038, 48.1166561643464);
+            lastSearchResult = nominatimClient.search(name);
+            for (Address addresse : lastSearchResult) {
+                retList.add(addresse.getDisplayName());
+            }
+            return retList;
+        } catch (IOException ex) {
+            Logger.getLogger(ExportDialogController.class.getName()).log(Level.SEVERE, null, ex);
+            return FXCollections.emptyObservableList();
+        }
+    }
+
+    /**
+     *
+     * @param longitude longitude of the address
+     * @param latitude latitude of the address
+     * @return the found address. Call getDisplayName to get string of the found
+     * address
+     */
+    public Address geoSearchForGPS(double longitude, double latitude) {
+        if (longitude < 0 || latitude < 0) {
+            return null;
+        }
+        if (longitude == 0 || latitude == 0) {
+            return null;
+        }
+        try {
+            lastSearchGPSResult = nominatimClient.getAddress(longitude, latitude);
+            return lastSearchGPSResult;
+        } catch (IOException ex) {
+            Logger.getLogger(ExportDialogController.class.getName()).log(Level.SEVERE, null, ex);
+            return null;
+        }
+    }
+
+    /**
+     *
+     * @return the client to do the resolution of any address
+     */
+    public JsonNominatimClient getNominatimClient() {
+        return nominatimClient;
+    }
+
+    /**
+     *
+     * @return results the list found for the given text during string search in
+     * DB
+     */
+    public List<Address> getLastSearchResult() {
+        return lastSearchResult;
+    }
+
+    /**
+     *
+     * @return if searched for lat/long value this item represents the resulting
+     * object
+     */
+    public Address getLastSearchGPSResult() {
+        return lastSearchGPSResult;
+    }
+
+    public void setLastSearchGPSResult(Address lastSearchGPSResult) {
+        this.lastSearchGPSResult = lastSearchGPSResult;
+    }
+
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/MetadataController.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/MetadataController.java
index a34beb8..0782701 100644
--- a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/MetadataController.java
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/MetadataController.java
@@ -16,6 +16,8 @@
 import com.icafe4j.image.meta.MetadataEntry;
 import com.icafe4j.image.meta.MetadataType;
 import com.icafe4j.image.meta.exif.Exif;
+import com.icafe4j.image.meta.exif.ExifTag;
+import com.icafe4j.image.meta.exif.GPSTag;
 import com.icafe4j.image.meta.image.Comments;
 import com.icafe4j.image.meta.iptc.IPTC;
 import com.icafe4j.image.meta.iptc.IPTCApplicationTag;
@@ -26,6 +28,9 @@
 import com.icafe4j.image.meta.xmp.XMP;
 import com.icafe4j.image.options.PNGOptions;
 import com.icafe4j.image.png.Filter;
+import com.icafe4j.image.tiff.FieldType;
+import com.icafe4j.image.tiff.IFD;
+import com.icafe4j.image.tiff.TiffField;
 import com.icafe4j.image.writer.ImageWriter;
 import com.sothawo.mapjfx.Coordinate;
 import com.sothawo.mapjfx.MapCircle;
@@ -111,6 +116,8 @@
 import javafx.scene.paint.Paint;
 import javafx.stage.Stage;
 import org.controlsfx.control.PopOver;
+import org.controlsfx.control.textfield.AutoCompletionBinding;
+import org.controlsfx.control.textfield.CustomTextField;
 import org.controlsfx.control.textfield.TextFields;
 import org.kordamp.ikonli.javafx.FontIcon;
 import org.librawfx.LibrawImage;
@@ -126,19 +133,20 @@
  * @author selfemp
  */
 public class MetadataController implements Initializable {
-
+    
     private ExecutorService executor;
     private MainViewController mainController;
     private LighttableController lightController;
     private Collection<String> keywordList;
     private MediaFile actualMediaFile;
-
+    
     private Exif exifdata;
     private IPTC iptcdata;
     private XMP xmpdata;
     private List<String> commentsdata;
     private HashMap<String, String> rawMetaData;
-
+    private GeoCoding geoCoding;
+    
     @FXML
     private Accordion accordionPane;
     @FXML
@@ -159,7 +167,7 @@ public class MetadataController implements Initializable {
     private TextField recordDateField;
     @FXML
     private AnchorPane anchorKeywordPane;
-
+    
     private Task<Boolean> task;
     private KeywordChangeListener keywordsChangeListener;
     private CommentsChangeListener commentsChangeListener;
@@ -190,7 +198,9 @@ public class MetadataController implements Initializable {
     private MapView map;
     private Marker markerPos;
     private MapCircle circle;
-
+    @FXML
+    private Button gpsPosButton;
+    
     @Override
     public void initialize(URL url, ResourceBundle rb) {
         executor = Executors.newSingleThreadExecutor(new ThreadFactoryPS("metaDataController"));
@@ -227,16 +237,17 @@ public void initialize(URL url, ResourceBundle rb) {
             });
             //actualMediaFile.requestLayout();
         });
+        geoCoding = new GeoCoding();
     }
-
+    
     public void injectMainController(MainViewController mainController) {
         this.mainController = mainController;
     }
-
+    
     public void injectLightController(LighttableController lightController) {
         this.lightController = lightController;
     }
-
+    
     public void setSelectedFile(MediaFile file) {
         actualMediaFile = file;
         resetGUI();
@@ -277,10 +288,10 @@ protected Boolean call() throws IOException {
             }
             anchorKeywordPane.setDisable(false);
             commentText.textProperty().addListener(commentsChangeListener);
-
+            
             keywordText.getChildren().addListener(keywordsChangeListener);
             captionTextField.textProperty().addListener(captionChangeListener);
-
+            
             if (file.getMediaType() == MediaFile.MediaTypes.VIDEO) {
                 Label key = new Label("File name");
                 Label value = new Label(file.getName());
@@ -289,7 +300,7 @@ protected Boolean call() throws IOException {
                 metaDataGrid.addRow(0, key, value);
             } else {
                 updateUIWithExtendedMetadata();
-
+                
                 gpsPlace.setText(actualMediaFile.getGpsPosition());
                 if (actualMediaFile.getGpsHeight() != -1) {
                     gpsHeight.setText("" + actualMediaFile.getGpsHeight() + " m");
@@ -309,7 +320,7 @@ protected Boolean call() throws IOException {
         });
         executor.submit(task);
     }
-
+    
     public synchronized void readBasicMetadata(Task actTask, MediaFile file) throws IOException {
         if (file.getMediaType() == MediaFile.MediaTypes.VIDEO) {
             return;
@@ -470,7 +481,7 @@ public synchronized void readBasicMetadata(Task actTask, MediaFile file) throws
                                     String formatTime = formatTime(gpsTimesb.toString());
                                     file.setGpsDateTime(gpsDateStr + "T" + formatTime);
                                 }
-                                file.setGpsPosition(gpsLatsb.toString() + gpsLatRefsb.toString() + ";" + gpsLongsb.toString() + gpsLongRefsb.toString());
+                                file.setGpsPositionFromDMS(gpsLatsb.toString() + gpsLatRefsb.toString() + ";" + gpsLongsb.toString() + gpsLongRefsb.toString());
                             }
                             if (item.getKey().equalsIgnoreCase("IFD0")) {
                                 entries.stream().forEach((mediaEntry) -> {
@@ -502,7 +513,7 @@ public synchronized void readBasicMetadata(Task actTask, MediaFile file) throws
             }
         }
     }
-
+    
     private String formatTime(String source) {
         if (source == null) {
             return "";
@@ -545,11 +556,11 @@ private String formatTime(String source) {
         }
         return finalStr;
     }
-
+    
     private void updateUIWithExtendedMetadata() {
         AtomicInteger i = new AtomicInteger(1);
         Iterator<MetadataEntry> iterator;
-
+        
         if (rawMetaData != null) {
             rawMetaData.entrySet().stream().sorted(Map.Entry.<String, String>comparingByKey()).forEach((entry) -> {
                 Label key = new Label(entry.getKey());
@@ -610,10 +621,10 @@ private void updateUIWithExtendedMetadata() {
                 });
             }
         }
-
+        
         metaDataGrid.setDisable(false);
     }
-
+    
     public void resetGUI() {
         Platform.runLater(() -> {
             metaDataGrid.getChildren().clear();
@@ -628,7 +639,7 @@ public void resetGUI() {
         keywordsChangeListener = new KeywordChangeListener();
         commentsChangeListener = new CommentsChangeListener();
         captionChangeListener = new CaptionChangeListener();
-
+        
         gpsDateTime.clear();
         gpsHeight.clear();
         gpsPlace.clear();
@@ -640,7 +651,7 @@ public void resetGUI() {
         apertureSlider.setValue(1);
         exposerFilter = null;
     }
-
+    
     @FXML
     private void addKeywordAction(KeyEvent event) {
         if (event.getCode() == KeyCode.ENTER) {
@@ -648,8 +659,8 @@ private void addKeywordAction(KeyEvent event) {
             addKeywordTextField.clear();
         }
     }
-
-    public void exportBasicMetadata(MediaFile mf, String exportFilePath) throws FileNotFoundException, IOException {
+    
+    public void exportBasicMetadata(MediaFile mf, String exportFilePath, boolean overwriteGPS) throws FileNotFoundException, IOException {
         if (exportFilePath.contains(".png")) {
             return;
         }
@@ -665,7 +676,7 @@ public void exportBasicMetadata(MediaFile mf, String exportFilePath) throws File
             dataSets.put(IPTCApplicationTag.KEY_WORDS, keywordListLocal);
         }
         keywordListLocal.clear();
-
+        
         String mfKeyw = mf.getKeywords();
         if (mfKeyw == null) {
             mfKeyw = "";
@@ -726,7 +737,7 @@ public void exportBasicMetadata(MediaFile mf, String exportFilePath) throws File
         }
         fin.close();
         bout.close();
-
+        
         fin = new FileInputStream(exportFilePath);
         bout = new ByteArrayOutputStream();
         if (commentsdata != null) {
@@ -737,13 +748,36 @@ public void exportBasicMetadata(MediaFile mf, String exportFilePath) throws File
         }
         fin.close();
         bout.close();
+        
+        if (overwriteGPS == true) {
+            //write GPS INfo
+            fin = new FileInputStream(exportFilePath);
+            bout = new ByteArrayOutputStream();
+            Exif exportExif;
+            if (exportFilePath.contains(".jpg")) {
+                exportExif = new JpegExif();
+            } else {
+                exportExif = new TiffExif();
+            }
+            exportExif.addGPSField(GPSTag.GPS_LATITUDE, FieldType.RATIONAL, mf.getGpsLatPosAsRational());
+            exportExif.addGPSField(GPSTag.GPS_LATITUDE_REF, FieldType.ASCII, mf.getGpsLatPosRef());
+            exportExif.addGPSField(GPSTag.GPS_LONGITUDE, FieldType.RATIONAL, mf.getGpsLonPosAsRational());
+            exportExif.addGPSField(GPSTag.GPS_LONGITUDE_REF, FieldType.ASCII, mf.getGpsLonPosRef());
+            exportExif.addGPSField(GPSTag.GPS_ALTITUDE, FieldType.RATIONAL, mf.getGpsHeightAsRational());
+            Metadata.insertExif(fin, bout, exportExif);
+            try ( OutputStream outputStream = new FileOutputStream(exportFilePath)) {
+                bout.writeTo(outputStream);
+            }
+            fin.close();
+            bout.close();
+        }
     }
-
-    public void exportCompleteMetdata(MediaFile mf, String exportFilePath, String extension) throws IOException {
+    
+    public void exportCompleteMetdata(MediaFile mf, String exportFilePath, String extension, boolean overwriteGPS) throws IOException {
         if (exportFilePath.contains(".png")) {
             return;
         }
-        exportBasicMetadata(mf, exportFilePath);
+        exportBasicMetadata(mf, exportFilePath, overwriteGPS);
         FileInputStream fin = new FileInputStream(exportFilePath);
         ByteArrayOutputStream bout = new ByteArrayOutputStream();
         Exif exportExif;
@@ -753,7 +787,9 @@ public void exportCompleteMetdata(MediaFile mf, String exportFilePath, String ex
             exportExif = new TiffExif();
         }
         exportExif.setExifIFD(exifdata.getExifIFD());
+        
         exportExif.setGPSIFD(exifdata.getGPSIFD());
+        
         if (!exportFilePath.contains(".tif")) {
             exportExif.setImageIFD(exifdata.getImageIFD());
         }
@@ -775,6 +811,36 @@ public void exportCompleteMetdata(MediaFile mf, String exportFilePath, String ex
         }
     }
 
+    /**
+     * Save the newly selected GPS info stored in MediaFile class to the media
+     * file
+     *
+     * @throws FileNotFoundException if the actual mediafile cannot be accessed
+     * @throws IOException if the actual mediafile cannot be accessed
+     */
+    private void updateGPSDataForActualMediaFile() throws FileNotFoundException, IOException {
+        ByteArrayOutputStream bout;
+        try ( FileInputStream fin = new FileInputStream(actualMediaFile.getPathStorage().toString())) {
+            bout = new ByteArrayOutputStream();
+            Exif exportExif;
+            if (actualMediaFile.getPathStorage().toString().contains(".jpg")) {
+                exportExif = new JpegExif();
+            } else {
+                exportExif = new TiffExif();
+            }
+            exportExif.addGPSField(GPSTag.GPS_LATITUDE, FieldType.RATIONAL, actualMediaFile.getGpsLatPosAsRational());
+            exportExif.addGPSField(GPSTag.GPS_LATITUDE_REF, FieldType.ASCII, actualMediaFile.getGpsLatPosRef());
+            exportExif.addGPSField(GPSTag.GPS_LONGITUDE, FieldType.RATIONAL, actualMediaFile.getGpsLonPosAsRational());
+            exportExif.addGPSField(GPSTag.GPS_LONGITUDE_REF, FieldType.ASCII, actualMediaFile.getGpsLonPosRef());
+            exportExif.addGPSField(GPSTag.GPS_ALTITUDE, FieldType.ASCII, actualMediaFile.getGpsHeight());
+            Metadata.insertExif(fin, bout, exportExif, true);
+            try ( OutputStream outputStream = new FileOutputStream(actualMediaFile.getPathStorage().toString())) {
+                bout.writeTo(outputStream);
+            }
+        }
+        bout.close();
+    }
+    
     private void saveComments() {
         progressPane.setVisible(true);
         progressIndicator.setProgress(ProgressIndicator.INDETERMINATE_PROGRESS);
@@ -792,9 +858,9 @@ protected Boolean call() throws IOException {
                 try {
                     bout = new ByteArrayOutputStream();
                     fin = new FileInputStream(actualMediaFile.getPathStorage().toFile());
-
+                    
                     Metadata.insertComment(fin, bout, commentText.getText());
-
+                    
                     try ( OutputStream outputStream = new FileOutputStream(actualMediaFile.getPathStorage().toFile())) {
                         bout.writeTo(outputStream);
                     }
@@ -821,7 +887,7 @@ protected Boolean call() throws IOException {
         });
         executor.submit(taskSaveComments);
     }
-
+    
     private String getKeywordsAsString(FlowPane kewordPane) {
         StringBuilder sb = new StringBuilder();
         if (!kewordPane.getChildren().isEmpty()) {
@@ -894,9 +960,9 @@ private void updateKeywordsTitle(MediaFile file, String title, String keywords)
         }
         try {
             bout = new ByteArrayOutputStream();
-
+            
             fin = new FileInputStream(file.getPathStorage().toFile());
-
+            
             if (iptcdata == null) {
                 iptcdata = new IPTC();
             }
@@ -907,7 +973,7 @@ private void updateKeywordsTitle(MediaFile file, String title, String keywords)
                 dataSets.put(IPTCApplicationTag.KEY_WORDS, keywordListLocal);
             }
             keywordListLocal.clear();
-
+            
             StringTokenizer defaultTokenizer = new StringTokenizer(keywords, ";");
             while (defaultTokenizer.hasMoreTokens()) {
                 keywordListLocal.add(new IPTCDataSet(IPTCApplicationTag.KEY_WORDS, defaultTokenizer.nextToken()));
@@ -932,7 +998,7 @@ private void updateKeywordsTitle(MediaFile file, String title, String keywords)
                 dataSets.put(IPTCApplicationTag.CAPTION_ABSTRACT, captionList);
             }
             captionList.add(new IPTCDataSet(IPTCApplicationTag.CAPTION_ABSTRACT, title));
-
+            
             List<IPTCDataSet> iptcs = new ArrayList<>();
             dataSets.entrySet().forEach((t) -> {
                 List<IPTCDataSet> tagValues = t.getValue();
@@ -957,7 +1023,7 @@ private void updateKeywordsTitle(MediaFile file, String title, String keywords)
             }
         }
     }
-
+    
     @FXML
     private void applyKeywordsToAllAction(ActionEvent event) {
         Alert alert = new Alert(Alert.AlertType.CONFIRMATION, "Apply Caption/Title and keywords to all mediafiles in event\n" + this.actualMediaFile.getPathStorage(), ButtonType.CANCEL, ButtonType.OK);
@@ -1010,7 +1076,7 @@ private void applyKeywordsToAllAction(ActionEvent event) {
             addKeywordToAllField.requestFocus();
         });
         content.addRow(2, new Pane(), addKeywordToAllField, addKewordButton);
-
+        
         dialogPane.setContent(content);
         dialogPane.getStylesheets().add(
                 getClass().getResource("/org/photoslide/css/Dialogs.css").toExternalForm());
@@ -1022,14 +1088,14 @@ private void applyKeywordsToAllAction(ActionEvent event) {
         alert.getDialogPane().getScene().setFill(Paint.valueOf("rgb(80, 80, 80)"));
         alert.showAndWait();
         if (alert.getResult() == ButtonType.OK) {
-
+            
             resetGUI();
             mainController.getProgressPane().setVisible(true);
             mainController.getProgressbar().setProgress(ProgressBar.INDETERMINATE_PROGRESS);
             mainController.getProgressbarLabel().setText("Setting metadata...");
             mainController.getStatusLabelLeft().setText("Setting metadata");
             mainController.getStatusLabelLeft().setVisible(true);
-
+            
             Task<Boolean> taskApplyToAll = new Task<>() {
                 @Override
                 protected Boolean call() throws Exception {
@@ -1079,13 +1145,13 @@ protected Boolean call() throws Exception {
             executor.submit(taskApplyToAll);
         }
     }
-
+    
     public void saveSettings() {
     }
-
+    
     public void restoreSettings() {
     }
-
+    
     @FXML
     private void resetAction(ActionEvent event) {
         actualMediaFile.removeImageFilter(exposerFilter);
@@ -1097,13 +1163,13 @@ private void resetAction(ActionEvent event) {
             exposerFilter = null;
         });
     }
-
+    
     @FXML
     private void showGPSPosition(ActionEvent event) {
         //System.out.println("action");
         showMap();
     }
-
+    
     private void showMap() {
         if (actualMediaFile.getGpsPosition() == null || actualMediaFile.getGpsPosition().equalsIgnoreCase(";")) {
             return;
@@ -1190,62 +1256,173 @@ private void showMap() {
         ((Parent) popOver.getSkin().getNode()).getStylesheets()
                 .add(getClass().getResource("/org/photoslide/css/PopOver.css").toExternalForm());
     }
-
+    
     @FXML
     private void showGPSPositionTouch(TouchEvent event) {
         showMap();
     }
-
+    
     @FXML
     private void showGPSPositionMouse(MouseEvent event) {
         showMap();
     }
-
+    
     @FXML
     private void showGPSPositionIconMouse(MouseEvent event) {
         showMap();
     }
-
+    
     @FXML
     private void showGPSPositionIconTouch(TouchEvent event) {
         showMap();
     }
-
+    
+    @FXML
+    private void changeGPSPosAction(ActionEvent event) {
+        if (actualMediaFile.getGpsPosition() == null || actualMediaFile.getGpsPosition().equalsIgnoreCase(";")) {
+            return;
+        }
+        Utility util = new Utility();
+        PopOver popOver = new PopOver();
+        popOver.setArrowLocation(PopOver.ArrowLocation.RIGHT_CENTER);
+        Label message = new Label("");
+        message.setVisible(false);
+        message.setManaged(false);
+        VBox vb = new VBox();
+        vb.setPadding(new Insets(10));
+        vb.setSpacing(5);
+        HBox hb = new HBox();
+        hb.setSpacing(5);
+        CustomTextField searchField = new CustomTextField();
+        Button searchButton = new Button();
+        searchButton.setGraphic(new FontIcon("ti-search:16"));
+        searchButton.setId("toolbutton");
+        searchButton.setOnAction((t) -> {
+            searchButtonAction(searchField);
+        });
+        searchField.setOnKeyPressed((p) -> {
+            event.consume();
+        });
+        Button saveButton=new Button();
+        saveButton.setGraphic(new FontIcon("ti-save:16"));
+        saveButton.setId("toolbutton");
+        saveButton.setOnAction((q) -> {
+            try {
+                updateGPSDataForActualMediaFile();
+            } catch (IOException ex) {
+                Logger.getLogger(MetadataController.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        });
+        hb.getChildren().add(new Label("Place:"));
+        hb.getChildren().add(searchField);
+        hb.getChildren().add(searchButton);
+        hb.getChildren().add(saveButton);
+        HBox hbHeight = new HBox();
+        hbHeight.setSpacing(5);
+        hbHeight.getChildren().add(new Label("Heigth:"));
+        CustomTextField heightField=new CustomTextField();
+        hbHeight.getChildren().add(heightField);
+        vb.getChildren().add(hbHeight);
+        vb.getChildren().add(hb);
+        map.setZoom(19);
+        double lat = actualMediaFile.getGpsLatPosAsDouble();
+        double lon = actualMediaFile.getGpsLonPosAsDouble();
+        Coordinate c = new Coordinate(lat, lon);
+        map.setCenter(c);
+        markerPos.setPosition(c).setVisible(true);
+        map.addMarker(markerPos);
+        circle = new MapCircle(c, 3);
+        circle.setVisible(true);
+        //circle.setFillColor(Color.TRANSPARENT);        
+        circle.setColor(javafx.scene.paint.Color.BLUE);
+        circle.setWidth(1);
+        map.addMapCircle(circle);
+        map.setEffect(new ColorAdjust(0, -0.5, 0, 0));
+        vb.getChildren().add(map);
+        vb.getChildren().add(message);
+        popOver.setContentNode(vb);
+        popOver.show(gpsPosButton);
+        ((Parent) popOver.getSkin().getNode()).getStylesheets()
+                .add(getClass().getResource("/org/photoslide/css/PopOver.css").toExternalForm());
+    }
+    
+    private void searchButtonAction(CustomTextField customField) {
+        String name = customField.getText();
+        
+        Task<ObservableList<String>> task = new Task<>() {
+            @Override
+            protected ObservableList<String> call() throws Exception {
+                return geoCoding.geoSearchForNameAsStrings(name);
+            }
+        };
+        task.setOnScheduled((t) -> {
+            ProgressIndicator ind = new ProgressIndicator();
+            ind.setPrefSize(10, 10);
+            ind.setMinSize(10, 10);
+            ind.setMaxSize(10, 10);
+            customField.setRight(ind);
+        });
+        task.setOnSucceeded((t) -> {
+            customField.setRight(null);
+            ObservableList<String> geoSearchForNameAsStrings = (ObservableList<String>) t.getSource().getValue();
+            //set autocomplete
+            AutoCompletionBinding<String> autoComp = TextFields.bindAutoCompletion(customField, geoSearchForNameAsStrings);
+            customField.setText(geoSearchForNameAsStrings.get(0));
+            customField.requestFocus();
+            autoComp.setUserInput(name);
+            autoComp.setOnAutoCompleted((o) -> {
+                int index = geoSearchForNameAsStrings.indexOf(customField.getText());
+                if (index == -1) {
+                    index = 0;
+                }
+                geoCoding.setLastSearchGPSResult(geoCoding.getLastSearchResult().get(index));
+                Coordinate c = new Coordinate(geoCoding.getLastSearchResult().get(index).getLatitude(), geoCoding.getLastSearchResult().get(index).getLongitude());
+                map.setCenter(c);
+                markerPos.setPosition(c).setVisible(true);
+                map.addMarker(markerPos);
+            });
+        });
+        task.setOnFailed((t) -> {
+            customField.setRight(null);
+        });
+        new Thread(task).start();
+    }
+    
     private class KeywordChangeListener implements ListChangeListener {
-
+        
         @Override
         public void onChanged(Change change) {
             saveKeywordsTitle(actualMediaFile);
         }
-
+        
     }
-
+    
     private class CommentsChangeListener implements ChangeListener<String> {
-
+        
         @Override
         public void changed(ObservableValue<? extends String> ov, String t, String t1) {
             saveComments();
         }
-
+        
     }
-
+    
     private class CaptionChangeListener implements ChangeListener<String> {
-
+        
         @Override
         public void changed(ObservableValue<? extends String> ov, String t, String t1) {
             saveKeywordsTitle(actualMediaFile);
         }
-
+        
     }
-
+    
     public void setActualMediaFile(MediaFile actualMediaFile) {
         this.actualMediaFile = actualMediaFile;
     }
-
+    
     public TextField getRecordDateField() {
         return recordDateField;
     }
-
+    
     public void cancelTasks() {
         if (task != null) {
             keywordText.getChildren().removeListener(keywordsChangeListener);
@@ -1255,23 +1432,23 @@ public void cancelTasks() {
             task.cancel();
         }
     }
-
+    
     public Slider getApertureSlider() {
         return apertureSlider;
     }
-
+    
     public Exif getExifdata() {
         return exifdata;
     }
-
+    
     public IPTC getIptcdata() {
         return iptcdata;
     }
-
+    
     public XMP getXmpdata() {
         return xmpdata;
     }
-
+    
     public List<String> getCommentsdata() {
         return commentsdata;
     }
@@ -1322,15 +1499,15 @@ public String getMetaDataAsString() {
         }*/
         return sb.toString();
     }
-
+    
     public void setExposerFilter(ImageFilter exposerFilter) {
         this.exposerFilter = exposerFilter;
     }
-
+    
     public HashMap<String, String> getRawMetaData() {
         return rawMetaData;
     }
-
+    
     public void Shutdown() {
         if (task != null) {
             task.cancel();
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/Point.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/Point.java
new file mode 100644
index 0000000..0702cc0
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/Point.java
@@ -0,0 +1,72 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+
+import java.io.Serializable;
+
+/**
+ * Represent a point in spherical system
+ */
+public class Point implements Serializable {
+    //decimal degrees
+    public final double latitude, longitude;
+
+    public Point(Coordinate latitude, Coordinate longitude) {
+        this.latitude = latitude.degrees();
+        this.longitude = longitude.degrees();
+    }
+
+    public Point(double latitude, double longitude) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+    }
+    
+    
+
+    /**
+     * Create a new Point.
+     *
+     * @param latitude  latitude
+     * @param longitude longitude
+     * @return the point
+     */
+    public static Point at(Coordinate latitude, Coordinate longitude) {
+        return new Point(latitude.degrees(), longitude.degrees());
+    }
+
+    @Override
+    public String toString() {
+        return "Point{" + "latitude=" + latitude + ", longitude=" + longitude + '}';
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/browsermetadata/RadianCoordinate.java b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/RadianCoordinate.java
new file mode 100644
index 0000000..ae9c7d8
--- /dev/null
+++ b/PhotoSlide/src/main/java/org/photoslide/browsermetadata/RadianCoordinate.java
@@ -0,0 +1,53 @@
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Grum Ltd (Romain Gallet)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of Geocalc nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.photoslide.browsermetadata;
+
+/**
+ * Represents coordinates given in
+ * radian-degrees (r) format
+ */
+public class RadianCoordinate extends Coordinate {
+
+    public final double radians;
+
+    public RadianCoordinate(double radians) {
+        this.radians = radians;
+    }
+    
+    
+
+    @Override
+    double degrees() {
+        return Math.toDegrees(radians);
+    }
+}
diff --git a/PhotoSlide/src/main/java/org/photoslide/datamodel/MediaFile.java b/PhotoSlide/src/main/java/org/photoslide/datamodel/MediaFile.java
index 2cfa92e..bbef9bb 100644
--- a/PhotoSlide/src/main/java/org/photoslide/datamodel/MediaFile.java
+++ b/PhotoSlide/src/main/java/org/photoslide/datamodel/MediaFile.java
@@ -46,6 +46,10 @@
 import javafx.scene.media.Media;
 import javafx.scene.media.MediaPlayer;
 import javafx.util.Callback;
+import org.photoslide.browsermetadata.Coordinate;
+import org.photoslide.browsermetadata.DMSCoordinate;
+import org.photoslide.browsermetadata.DegreeCoordinate;
+import org.photoslide.browsermetadata.Point;
 import org.photoslide.imageops.ImageFilter;
 
 /**
@@ -81,7 +85,7 @@ public class MediaFile {
     private FileTime creationTime;
     private boolean subViewSelected;
     private ObservableList<ImageFilter> filterList;
-    private String gpsPosition;
+    private Point gpsPosition;
     private LocalDateTime gpsDateTime;
     private double gpsHeight;
     private final SimpleBooleanProperty bookmarked;
@@ -239,7 +243,7 @@ public void saveEdits() {
                 prop.setProperty("gpsHeight", "" + gpsHeight);
             }
             if (gpsPosition != null) {
-                prop.setProperty("gpsPosition", gpsPosition);
+                prop.setProperty("gpsPosition", gpsPosition.latitude + ";" + gpsPosition.longitude);
             }
             prop.store(output, null);
 
@@ -343,11 +347,15 @@ public void readEdits() {
                     }
                 }
             }
-            if (gpsHeight != -1) {
+            if (prop.getProperty("gpsHeight", null) != null) {
                 gpsHeight = Double.parseDouble(prop.getProperty("gpsHeight", "-1"));
             }
-            if (gpsPosition != null) {
-                gpsPosition = prop.getProperty("gpsPosition", null);
+            if (prop.getProperty("gpsPosition") != null) {
+                String property = prop.getProperty("gpsPosition");
+                StringTokenizer token = new StringTokenizer(property, ";");
+                double lat = Double.parseDouble(token.nextToken());
+                double lon = Double.parseDouble(token.nextToken());
+                gpsPosition = new Point(lat, lon);
             }
         } catch (IOException ex) {
             //Do nothing if file not found
@@ -626,55 +634,128 @@ public SimpleStringProperty commentsProperty() {
     }
 
     public String getGpsPosition() {
-        return gpsPosition;
-    }
-
-    public double getGpsLatPosAsDouble() {
-        if (gpsPosition == null || gpsPosition.equalsIgnoreCase(";")) {
-            return -1;
-        }
-        String degree = gpsPosition.substring(0, gpsPosition.indexOf("°"));
-        String minutes = gpsPosition.substring(gpsPosition.indexOf("°") + 1, gpsPosition.indexOf("'"));
-        String seconds = gpsPosition.substring(gpsPosition.indexOf("'") + 1, gpsPosition.indexOf("\""));
-        if (seconds.contains(",")) {
-            seconds = seconds.replace(",", ".");
+        String latRef, lonRef;
+        DegreeCoordinate fromDegreesLat = Coordinate.fromDegrees(gpsPosition.latitude);
+        DegreeCoordinate fromDegreesLon = Coordinate.fromDegrees(gpsPosition.longitude);
+        if (gpsPosition.latitude < 0) {
+            latRef = "S";
+        } else {
+            latRef = "N";
         }
-        if (minutes.contains(",")) {
-            minutes = minutes.replace(",", ".");
+        if (gpsPosition.longitude < 0) {
+            lonRef = "W";
+        } else {
+            lonRef = "E";
         }
-        double d = Double.parseDouble(degree);
-        double m = Double.parseDouble(minutes);
-        double s = Double.parseDouble(seconds);
-        double dd = Math.signum(d) * (Math.abs(d) + (m / 60.0) + (s / 3600.0));
-        return dd;
+        DMSCoordinate toDMSCoordinateLat = fromDegreesLat.toDMSCoordinate();
+        DMSCoordinate toDMSCoordinateLon = fromDegreesLon.toDMSCoordinate();
+        String ret = toDMSCoordinateLat.wholeDegrees + "°" + toDMSCoordinateLat.minutes + "'" + toDMSCoordinateLat.seconds + "''" + latRef;
+        ret = ret + ";" + toDMSCoordinateLon.wholeDegrees + "°" + toDMSCoordinateLon.minutes + "'" + toDMSCoordinateLon.seconds + "''" + lonRef;
+        return ret;
     }
 
+    public double getGpsLatPosAsDouble() {
+        return gpsPosition.latitude;
+
+    }
+    
     public double getGpsLonPosAsDouble() {
-        if (gpsPosition == null || gpsPosition.equalsIgnoreCase(";")) {
+        return gpsPosition.longitude;
+
+    }
+
+    public double parseGPSString(String source) {
+        if (source == null || source.equalsIgnoreCase(";")) {
             return -1;
         }
-        int start = gpsPosition.indexOf(";") + 1;
-        String degree = gpsPosition.substring(start, gpsPosition.lastIndexOf("°"));
-        String minutes = gpsPosition.substring(gpsPosition.lastIndexOf("°") + 1, gpsPosition.lastIndexOf("'"));
-        String seconds = gpsPosition.substring(gpsPosition.lastIndexOf("'") + 1, gpsPosition.lastIndexOf("\""));
+        String degree = source.substring(0, source.indexOf("°"));
+        String minutes = source.substring(source.indexOf("°") + 1, source.indexOf("'"));
+        String seconds = source.substring(source.indexOf("'") + 1, source.indexOf("\""));
         if (seconds.contains(",")) {
             seconds = seconds.replace(",", ".");
         }
         if (minutes.contains(",")) {
             minutes = minutes.replace(",", ".");
         }
-        if (degree.contains(",")) {
-            degree = degree.replace(",", ".");
-        }
         double d = Double.parseDouble(degree);
         double m = Double.parseDouble(minutes);
         double s = Double.parseDouble(seconds);
         double dd = Math.signum(d) * (Math.abs(d) + (m / 60.0) + (s / 3600.0));
-        return dd;
+        DMSCoordinate dms = new DMSCoordinate(d, m, s);
+        return dms.toDegreeCoordinate().decimalDegrees;
+    }
+
+    public int[] getGpsLatPosAsRational() {
+        int[] rat1 = new int[6];
+        DegreeCoordinate fromDegreesLat = Coordinate.fromDegrees(gpsPosition.latitude);
+        DMSCoordinate toDMSCoordinate = fromDegreesLat.toDMSCoordinate();
+        double d = toDMSCoordinate.wholeDegrees;
+        double m = toDMSCoordinate.minutes;
+        double s = toDMSCoordinate.seconds;
+        rat1[0] = (int) d;
+        rat1[1] = 1;
+        rat1[2] = (int) m;
+        rat1[3] = 1;
+        rat1[4] = (int) s;
+        rat1[5] = 100;
+        return rat1;
+    }
+
+    public String getGpsLatPosRef() {
+        String latRef;
+        if (gpsPosition.latitude < 0) {
+            latRef = "S";
+        } else {
+            latRef = "N";
+        }
+        return latRef;
+    }
+
+    public int[] getGpsLonPosAsRational() {
+        int[] rat1 = new int[6];
+        DegreeCoordinate fromDegrees = Coordinate.fromDegrees(gpsPosition.longitude);
+        DMSCoordinate toDMSCoordinate = fromDegrees.toDMSCoordinate();
+        double d = toDMSCoordinate.wholeDegrees;
+        double m = toDMSCoordinate.minutes;
+        double s = toDMSCoordinate.seconds;
+        rat1[0] = (int) d;
+        rat1[1] = 1;
+        rat1[2] = (int) m;
+        rat1[3] = 1;
+        rat1[4] = (int) s;
+        rat1[5] = 100;
+        return rat1;
+    }
+    
+    public int[] getGpsHeightAsRational(){
+      int[] rat1 = new int[2]; 
+      rat1[0]=(int)gpsHeight*10000;
+      rat1[1]=10000;
+      return rat1;
+    }
+
+    public String getGpsLonPosRef() {
+        String lonRef;
+        if (gpsPosition.latitude < 0) {
+            lonRef = "W";
+        } else {
+            lonRef = "E";
+        }
+        return lonRef;
     }
 
-    public void setGpsPosition(String gpsPosition) {
-        this.gpsPosition = gpsPosition;
+    public void setGpsPositionFromDMS(String gpsPosition) {
+        StringTokenizer token = new StringTokenizer(gpsPosition, ";");
+        double lat = parseGPSString(token.nextToken());
+        double lon = parseGPSString(token.nextToken());
+        this.gpsPosition = new Point(lat, lon);
+    }
+    
+    public void setGpsPositionFromDegree(String gpsPosition) {
+        StringTokenizer token = new StringTokenizer(gpsPosition, ";");
+        double lat = Double.parseDouble(token.nextToken());
+        double lon = Double.parseDouble(token.nextToken());
+        this.gpsPosition = new Point(lat, lon);
     }
 
     public LocalDateTime getGpsDateTime() {
diff --git a/PhotoSlide/src/main/resources/org/photoslide/fxml/BrowserMetadata.fxml b/PhotoSlide/src/main/resources/org/photoslide/fxml/BrowserMetadata.fxml
index 0399255..170cbbe 100644
--- a/PhotoSlide/src/main/resources/org/photoslide/fxml/BrowserMetadata.fxml
+++ b/PhotoSlide/src/main/resources/org/photoslide/fxml/BrowserMetadata.fxml
@@ -23,7 +23,7 @@
 <?import javafx.scene.text.Font?>
 <?import org.kordamp.ikonli.javafx.FontIcon?>
 
-<AnchorPane prefWidth="258.0" stylesheets="@../css/MainView.css" xmlns="http://javafx.com/javafx/16" xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.photoslide.browsermetadata.MetadataController">
+<AnchorPane prefWidth="258.0" stylesheets="@../css/MainView.css" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.photoslide.browsermetadata.MetadataController">
    <children>
       <Label layoutX="21.0" layoutY="81.0" text="MetaData" textFill="#9f9f9f" AnchorPane.leftAnchor="10.0" AnchorPane.topAnchor="10.0">
          <font>
@@ -67,7 +67,7 @@
                                           <TextField fx:id="addKeywordTextField" onKeyPressed="#addKeywordAction" prefHeight="27.0" prefWidth="205.0" promptText="Add Keywords..." />
                                           <HBox alignment="CENTER_RIGHT">
                                              <children>
-                                                <Button mnemonicParsing="false" onAction="#applyKeywordsToAllAction" text="Apply to all images...">
+                                                <Button mnemonicParsing="false" onAction="#applyKeywordsToAllAction" text="Apply to all/sel. mediafiles...">
                                                    <font>
                                                       <Font size="10.0" />
                                                    </font>
@@ -111,9 +111,18 @@
                                           </TextField>
                                        </children>
                                     </GridPane>
+                                    <HBox alignment="TOP_RIGHT">
+                                       <children>
+                                          <Button fx:id="gpsPosButton" mnemonicParsing="false" onAction="#changeGPSPosAction" text="Change GPS position">
+                                             <font>
+                                                <Font size="10.0" />
+                                             </font>
+                                          </Button>
+                                       </children>
+                                    </HBox>
                                  </children>
                               </VBox>
-                              <VBox layoutX="18.4" layoutY="315.4" prefHeight="120.0" prefWidth="226.0" AnchorPane.leftAnchor="-8.0" AnchorPane.rightAnchor="-8.0" AnchorPane.topAnchor="410.0">
+                              <VBox layoutX="-8.0" layoutY="428.0" prefHeight="120.0" prefWidth="226.0" AnchorPane.leftAnchor="-8.0" AnchorPane.rightAnchor="-8.0" AnchorPane.topAnchor="428.0">
                                  <children>
                                     <Label text="Comments" />
                                     <TextArea fx:id="commentText" prefHeight="200.0" prefWidth="200.0" wrapText="true" />
diff --git a/PhotoSlide/src/main/resources/org/photoslide/fxml/ExportDialog.fxml b/PhotoSlide/src/main/resources/org/photoslide/fxml/ExportDialog.fxml
index b1885f3..9eeb999 100644
--- a/PhotoSlide/src/main/resources/org/photoslide/fxml/ExportDialog.fxml
+++ b/PhotoSlide/src/main/resources/org/photoslide/fxml/ExportDialog.fxml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
+<?import com.sothawo.mapjfx.MapView?>
 <?import javafx.geometry.Insets?>
 <?import javafx.scene.control.Button?>
 <?import javafx.scene.control.CheckBox?>
@@ -16,12 +17,13 @@
 <?import javafx.scene.layout.HBox?>
 <?import javafx.scene.layout.RowConstraints?>
 <?import javafx.scene.layout.VBox?>
+<?import org.controlsfx.control.textfield.CustomTextField?>
 <?import org.kordamp.ikonli.javafx.FontIcon?>
 
-<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="538.0" prefWidth="511.0" stylesheets="@../css/Dialogs.css" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.photoslide.ExportDialogController">
+<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="399.0" prefWidth="911.0" stylesheets="@../css/Dialogs.css" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.photoslide.ExportDialogController">
    <children>
       <Label layoutX="84.0" layoutY="71.0" text="Filesequence" />
-      <ComboBox fx:id="fileSequenceCombo" layoutX="164.0" layoutY="66.0" prefHeight="27.0" prefWidth="161.0" />
+      <ComboBox fx:id="fileSequenceCombo" layoutX="164.0" layoutY="66.0" prefHeight="27.0" prefWidth="149.0" />
       <Label layoutX="67.0" layoutY="143.0" text="Output directory" />
       <TextField fx:id="outputDirText" editable="false" layoutX="164.0" layoutY="139.0" />
       <Button layoutX="332.0" layoutY="139.0" mnemonicParsing="false" onAction="#outputSelectionButtonAction">
@@ -32,9 +34,9 @@
       <TextField fx:id="filenamePrefixText" layoutX="164.0" layoutY="101.0" />
       <Label layoutX="77.0" layoutY="106.0" text="Filenameprefix" />
       <Label layoutX="334.0" layoutY="106.0" text="Example:" />
-      <Label fx:id="exampleLabel" layoutX="392.0" layoutY="106.0" text="wildeben_1.jpg" textFill="#a8a4a4" />
+      <Label fx:id="exampleLabel" layoutX="392.0" layoutY="106.0" prefHeight="17.0" prefWidth="112.0" text="wildeben_1.jpg" textFill="#a8a4a4" textOverrun="CENTER_ELLIPSIS" />
       <Label layoutX="102.0" layoutY="36.0" text="Fileformat" />
-      <ComboBox fx:id="fileFormatCombo" layoutX="164.0" layoutY="31.0" prefHeight="27.0" prefWidth="161.0" />
+      <ComboBox fx:id="fileFormatCombo" layoutX="164.0" layoutY="31.0" prefHeight="27.0" prefWidth="149.0" />
       <GridPane hgap="10.0" layoutX="81.0" layoutY="213.0">
         <columnConstraints>
           <ColumnConstraints hgrow="SOMETIMES" maxWidth="170.0" minWidth="10.0" prefWidth="170.0" />
@@ -59,12 +61,12 @@
          </tooltip>
       </Slider>
       <Label fx:id="errorLabelDirectory" layoutX="367.0" layoutY="143.0" text="Label" textFill="#ff0101" visible="false" />
-      <VBox layoutX="81.0" layoutY="356.0" prefHeight="123.0" prefWidth="350.0" spacing="2.0">
+      <VBox layoutX="523.0" layoutY="77.0" prefHeight="123.0" prefWidth="350.0" spacing="2.0">
          <children>
             <CheckBox fx:id="replaceKeywordChoiceBox" mnemonicParsing="false" text="Replace keywords during export" />
-            <ScrollPane fitToWidth="true" minViewportHeight="90.0" minViewportWidth="100.0" prefViewportWidth="230.0">
+            <ScrollPane fitToWidth="true" minViewportHeight="90.0" minViewportWidth="100.0" prefViewportWidth="230.0" prefWidth="350.0">
                <content>
-                  <FlowPane fx:id="keywordText" disable="true" hgap="5.0" prefHeight="100.0" prefWidth="230.0" style="-fx-background-color: rgb(80, 80, 80);" vgap="5.0">
+                  <FlowPane fx:id="keywordText" disable="true" hgap="5.0" prefHeight="100.0" prefWidth="348.0" style="-fx-background-color: rgb(80, 80, 80);" vgap="5.0">
                      <padding>
                         <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
                      </padding>
@@ -83,11 +85,29 @@
             </HBox>
          </children>
       </VBox>
-      <HBox alignment="CENTER_LEFT" layoutX="81.0" layoutY="319.0" prefHeight="25.0" prefWidth="350.0" spacing="10.0">
+      <HBox alignment="CENTER_LEFT" layoutX="523.0" layoutY="32.0" prefHeight="25.0" prefWidth="350.0" spacing="10.0">
          <children>
             <CheckBox fx:id="replaceTitleBox" mnemonicParsing="false" text="Replace Title during export" />
             <TextField fx:id="titleTextBox" disable="true" HBox.hgrow="ALWAYS" />
          </children>
       </HBox>
+      <CheckBox fx:id="replaceGPSCheckBox" layoutX="523.0" layoutY="258.0" mnemonicParsing="false" text="Replace GPS information" />
+      <VBox fx:id="mapSelectionPane" disable="true" layoutX="523.0" layoutY="278.0" spacing="5.0">
+         <children>
+            <HBox alignment="CENTER_LEFT" prefHeight="25.0" prefWidth="302.0" spacing="5.0">
+               <children>
+                  <CustomTextField fx:id="customField" onKeyPressed="#searchTFPressed" prefHeight="25.0" prefWidth="176.0" />
+                  <Button fx:id="searchButton" mnemonicParsing="false" onAction="#searchButtonAction">
+                     <graphic>
+                        <FontIcon iconLiteral="ti-search" />
+                     </graphic>
+                  </Button>
+                  <Label text="Height" />
+                  <CustomTextField fx:id="heightTextField" prefHeight="25.0" prefWidth="95.0" />
+               </children>
+            </HBox>
+            <MapView fx:id="mapView" prefHeight="90.0" prefWidth="350.0" />
+         </children>
+      </VBox>
    </children>
 </AnchorPane>