Index: src/org/openstreetmap/josm/actions/SimplifyWayAction.java
===================================================================
--- src/org/openstreetmap/josm/actions/SimplifyWayAction.java	(revision 16392)
+++ src/org/openstreetmap/josm/actions/SimplifyWayAction.java	(working copy)
@@ -26,6 +26,7 @@
 import javax.swing.JSpinner;
 import javax.swing.SpinnerNumberModel;
 import javax.swing.SwingUtilities;
+import javax.swing.event.ChangeListener;
 
 import org.openstreetmap.josm.command.ChangeCommand;
 import org.openstreetmap.josm.command.Command;
@@ -48,6 +49,7 @@
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.Shortcut;
+import org.openstreetmap.josm.tools.Utils;
 
 /**
  * Delete unnecessary nodes from a way
@@ -112,6 +114,18 @@
      * @since 15419
      */
     public static double askSimplifyWays(String text, boolean auto) {
+        return askSimplifyWays(Collections.emptyList(), text, auto);
+    }
+
+    /**
+     * Asks the user for max-err value used to simplify ways, if not remembered before
+     * @param ways the ways that are being simplified (to show estimated number of nodes to be removed)
+     * @param text the text being shown
+     * @param auto whether it's called automatically (conversion) or by the user
+     * @return the max-err value or -1 if canceled
+     * @since xxx
+     */
+    public static double askSimplifyWays(List<Way> ways, String text, boolean auto) {
         IPreferences s = Config.getPref();
         String key = "simplify-way." + (auto ? "auto." : "");
         String keyRemember = key + "remember";
@@ -132,10 +146,24 @@
         p.setBorder(BorderFactory.createEmptyBorder(5, 10, 10, 5));
         JPanel q = new JPanel(new GridBagLayout());
         q.add(new JLabel(tr("Maximum error (meters): ")));
-        JSpinner n = new JSpinner(new SpinnerNumberModel(
-                s.getDouble(keyError, 3.0), 0.01, null, 0.5));
+        SpinnerNumberModel errorModel = new SpinnerNumberModel(
+                s.getDouble(keyError, 3.0), 0.01, null, 0.5);
+        JSpinner n = new JSpinner(errorModel);
         ((JSpinner.DefaultEditor) n.getEditor()).getTextField().setColumns(4);
         q.add(n);
+        if (!ways.isEmpty()) {
+            JLabel estNodesToRemove = new JLabel();
+            ChangeListener l = e -> {
+                int removeNodes = simplifyWaysCountNodesRemoved(ways, errorModel.getNumber().doubleValue());
+                estNodesToRemove.setText(trn("(about {0} node to remove)",
+                        "(about {0} nodes to remove)", removeNodes, removeNodes
+                        ));
+            };
+            errorModel.addChangeListener(l);
+            l.stateChanged(null);
+            q.add(estNodesToRemove);
+            errorModel.getChangeListeners();
+        }
         q.setBorder(BorderFactory.createEmptyBorder(14, 0, 10, 0));
         p.add(q, GBC.eol());
         JCheckBox c = new JCheckBox(tr("Do not ask again"));
@@ -185,7 +213,7 @@
             String lengthstr = SystemOfMeasurement.getSystemOfMeasurement().getDistText(
                     ways.stream().mapToDouble(Way::getLength).sum());
 
-            double err = askSimplifyWays(trn(
+            double err = askSimplifyWays(ways, trn(
                     "You are about to simplify {0} way with a total length of {1}.",
                     "You are about to simplify {0} ways with a total length of {1}.",
                     ways.size(), ways.size(), lengthstr), false);
@@ -244,9 +272,40 @@
      *
      * @param ways the ways to simplify
      * @param threshold the max error threshold
+     * @return The number of nodes removed from the ways (does not double-count)
+     * @since xxx
+     */
+    public static int simplifyWaysCountNodesRemoved(List<Way> ways, double threshold) {
+        Command command = buildSimplifyWaysCommand(ways, threshold);
+        if (command == null) {
+            return 0;
+        }
+        return Utils.filteredCollection(new ArrayList<>(command.getParticipatingPrimitives()), Node.class).size();
+    }
+
+    /**
+     * Runs the commands to simplify the ways with the given threshold
+     *
+     * @param ways the ways to simplify
+     * @param threshold the max error threshold
      * @since 15419
      */
     public static void simplifyWays(List<Way> ways, double threshold) {
+        Command command = buildSimplifyWaysCommand(ways, threshold);
+        if (command != null) {
+            UndoRedoHandler.getInstance().add(command);
+        }
+    }
+
+    /**
+     * Creates the commands to simplify the ways with the given threshold
+     *
+     * @param ways the ways to simplify
+     * @param threshold the max error threshold
+     * @return The command to simplify ways
+     * @since xxx (private)
+     */
+    private static SequenceCommand buildSimplifyWaysCommand(List<Way> ways, double threshold) {
         Collection<Command> allCommands = new LinkedList<>();
         for (Way way : ways) {
             SequenceCommand simplifyCommand = createSimplifyCommand(way, threshold);
@@ -256,11 +315,10 @@
             allCommands.add(simplifyCommand);
         }
         if (allCommands.isEmpty())
-            return;
-        SequenceCommand rootCommand = new SequenceCommand(
+            return null;
+        return new SequenceCommand(
                 trn("Simplify {0} way", "Simplify {0} ways", allCommands.size(), allCommands.size()),
                 allCommands);
-        UndoRedoHandler.getInstance().add(rootCommand);
     }
 
     /**