Index: /applications/editors/josm/plugins/cadastre-fr/build.xml =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/build.xml (revision 33636) +++ /applications/editors/josm/plugins/cadastre-fr/build.xml (revision 33637) @@ -10,5 +10,5 @@ --> - + Index: /applications/editors/josm/plugins/cadastre-fr/src/META-INF/MANIFEST.MF =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/META-INF/MANIFEST.MF (revision 33636) +++ /applications/editors/josm/plugins/cadastre-fr/src/META-INF/MANIFEST.MF (revision 33637) @@ -1,4 +1,4 @@ Manifest-Version: 1.0 -Plugin-Class: cadastre_fr.CadastrePlugin +Plugin-Class: org.openstreetmap.josm.plugins.fr.cadastre.CadastrePlugin Plugin-Description: A special handler for the French land registry WMS server Plugin-Version: 2.6 Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/Address.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/Address.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/Address.java (revision 33637) @@ -0,0 +1,540 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.Cursor; +import java.awt.GridBagLayout; +import java.awt.Point; +import java.awt.Rectangle; +import java.awt.Toolkit; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ComponentAdapter; +import java.awt.event.ComponentEvent; +import java.awt.event.KeyEvent; +import java.awt.event.MouseEvent; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.swing.ButtonGroup; +import javax.swing.ImageIcon; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JDialog; +import javax.swing.JLabel; +import javax.swing.JOptionPane; +import javax.swing.JPanel; +import javax.swing.JRadioButton; +import javax.swing.JTextField; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.actions.mapmode.MapMode; +import org.openstreetmap.josm.command.AddCommand; +import org.openstreetmap.josm.command.ChangeCommand; +import org.openstreetmap.josm.command.ChangePropertyCommand; +import org.openstreetmap.josm.command.Command; +import org.openstreetmap.josm.command.SequenceCommand; +import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.osm.Relation; +import org.openstreetmap.josm.data.osm.RelationMember; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.osm.WaySegment; +import org.openstreetmap.josm.gui.MapView; +import org.openstreetmap.josm.tools.GBC; +import org.openstreetmap.josm.tools.ImageProvider; +import org.openstreetmap.josm.tools.Pair; +import org.openstreetmap.josm.tools.Shortcut; + +public class Address extends MapMode { + + // perhaps make all these tags configurable in the future + private String tagHighway = "highway"; + private String tagHighwayName = "name"; + private String tagHouseNumber = "addr:housenumber"; + private String tagHouseStreet = "addr:street"; + private String tagBuilding = "building"; + private String relationAddrType = "associatedStreet"; + private String relationAddrName = "name"; + private String relationAddrStreetRole = "street"; + private String relationMemberHouse = "house"; + + private JRadioButton plusOne = new JRadioButton("+1", false); + private JRadioButton plusTwo = new JRadioButton("+2", true); // enable this by default + private JRadioButton minusOne = new JRadioButton("-1", false); + private JRadioButton minusTwo = new JRadioButton("-2", false); + final JCheckBox tagPolygon = new JCheckBox(tr("on polygon")); + + JDialog dialog; + JButton clearButton; + final JTextField inputNumber = new JTextField(); + final JTextField inputStreet = new JTextField(); + JLabel link = new JLabel(); + private transient Way selectedWay; + private boolean shift; + private boolean ctrl; + + /** + * Constructs a new {@code Address} map mode. + */ + public Address() { + super(tr("Add address"), "buildings", + tr("Helping tool for tag address"), + // CHECKSTYLE.OFF: LineLength + Shortcut.registerShortcut("mapmode:cadastre-fr-buildings", tr("Mode: {0}", tr("CadastreFR - Buildings")), KeyEvent.VK_E, Shortcut.DIRECT), + // CHECKSTYLE.ON: LineLength + getCursor()); + } + + @Override public void enterMode() { + super.enterMode(); + if (dialog == null) { + createDialog(); + } + dialog.setVisible(true); + Main.map.mapView.addMouseListener(this); + } + + @Override public void exitMode() { + if (Main.map.mapView != null) { + super.exitMode(); + Main.map.mapView.removeMouseListener(this); + } + // kill the window completely to fix an issue on some linux distro and full screen mode. + if (dialog != null) { + dialog.dispose(); + dialog = null; + } + } + + @Override + public void mousePressed(MouseEvent e) { + if (e.getButton() != MouseEvent.BUTTON1) + return; + shift = (e.getModifiers() & ActionEvent.SHIFT_MASK) != 0; + ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) != 0; + MapView mv = Main.map.mapView; + Point mousePos = e.getPoint(); + List mouseOnExistingWays = new ArrayList<>(); + List mouseOnExistingBuildingWays = new ArrayList<>(); + Node currentMouseNode = mv.getNearestNode(mousePos, OsmPrimitive::isSelectable); + if (currentMouseNode != null) { + // click on existing node + setNewSelection(currentMouseNode); + String num = currentMouseNode.get(tagHouseNumber); + if (num != null + && currentMouseNode.get(tagHouseStreet) == null + && findWayInRelationAddr(currentMouseNode) == null + && !inputStreet.getText().isEmpty()) { + // house number already present but not linked to a street + Collection cmds = new LinkedList<>(); + addStreetNameOrRelation(currentMouseNode, cmds); + Command c = new SequenceCommand("Add node address", cmds); + Main.main.undoRedo.add(c); + setNewSelection(currentMouseNode); + } else { + if (num != null) { + try { + // add new address + Integer.parseInt(num); + inputNumber.setText(num); + applyInputNumberChange(); + } catch (NumberFormatException en) { + Main.warn("Unable to parse house number \"" + num + "\""); + } + } + if (currentMouseNode.get(tagHouseStreet) != null) { + if (Main.pref.getBoolean("cadastrewms.addr.dontUseRelation", false)) { + inputStreet.setText(currentMouseNode.get(tagHouseStreet)); + if (ctrl) { + Collection cmds = new LinkedList<>(); + addAddrToPrimitive(currentMouseNode, cmds); + if (num == null) + applyInputNumberChange(); + } + setSelectedWay((Way) null); + } + } else { + // check if the node belongs to an associatedStreet relation + Way wayInRelationAddr = findWayInRelationAddr(currentMouseNode); + if (wayInRelationAddr == null) { + // node exists but doesn't carry address information : add tags like a new node + if (ctrl) { + applyInputNumberChange(); + } + Collection cmds = new LinkedList<>(); + addAddrToPrimitive(currentMouseNode, cmds); + } else { + inputStreet.setText(wayInRelationAddr.get(tagHighwayName)); + setSelectedWay(wayInRelationAddr); + } + } + } + } else { + List wss = mv.getNearestWaySegments(mousePos, OsmPrimitive::isSelectable); + for (WaySegment ws : wss) { + if (ws.way.get(tagHighway) != null && ws.way.get(tagHighwayName) != null) + mouseOnExistingWays.add(ws.way); + else if (ws.way.get(tagBuilding) != null && ws.way.get(tagHouseNumber) == null) + mouseOnExistingBuildingWays.add(ws.way); + } + if (mouseOnExistingWays.size() == 1) { + // clicked on existing highway => set new street name + inputStreet.setText(mouseOnExistingWays.get(0).get(tagHighwayName)); + setSelectedWay(mouseOnExistingWays.get(0)); + inputNumber.setText(""); + setNewSelection(mouseOnExistingWays.get(0)); + } else if (mouseOnExistingWays.isEmpty()) { + // clicked a non highway and not a node => add the new address + if (inputStreet.getText().isEmpty() || inputNumber.getText().isEmpty()) { + Toolkit.getDefaultToolkit().beep(); + } else { + Collection cmds = new LinkedList<>(); + if (ctrl) { + applyInputNumberChange(); + } + if (tagPolygon.isSelected()) { + addAddrToPolygon(mouseOnExistingBuildingWays, cmds); + } else { + Node n = createNewNode(e, cmds); + addAddrToPrimitive(n, cmds); + } + } + } + } + } + + private Way findWayInRelationAddr(Node n) { + List l = n.getReferrers(); + for (OsmPrimitive osm : l) { + if (osm instanceof Relation && osm.hasKey("type") && osm.get("type").equals(relationAddrType)) { + for (RelationMember rm : ((Relation) osm).getMembers()) { + if (rm.getRole().equals(relationAddrStreetRole)) { + OsmPrimitive osp = rm.getMember(); + if (osp instanceof Way && osp.hasKey(tagHighwayName)) { + return (Way) osp; + } + } + } + } + } + return null; + } + + private void addAddrToPolygon(List mouseOnExistingBuildingWays, Collection cmds) { + for (Way w:mouseOnExistingBuildingWays) { + addAddrToPrimitive(w, cmds); + } + } + + private void addAddrToPrimitive(OsmPrimitive osm, Collection cmds) { + // add the current tag addr:housenumber in node and member in relation (if so configured) + if (shift) { + try { + revertInputNumberChange(); + } catch (NumberFormatException en) { + Main.warn("Unable to parse house number \"" + inputNumber.getText() + "\""); + } + } + cmds.add(new ChangePropertyCommand(osm, tagHouseNumber, inputNumber.getText())); + addStreetNameOrRelation(osm, cmds); + try { + applyInputNumberChange(); + Command c = new SequenceCommand("Add node address", cmds); + Main.main.undoRedo.add(c); + setNewSelection(osm); + } catch (NumberFormatException en) { + Main.warn("Unable to parse house number \"" + inputNumber.getText() + "\""); + } + } + + private Relation findRelationAddr(Way w) { + List l = w.getReferrers(); + for (OsmPrimitive osm : l) { + if (osm instanceof Relation && osm.hasKey("type") && osm.get("type").equals(relationAddrType)) { + return (Relation) osm; + } + } + return null; + } + + private void addStreetNameOrRelation(OsmPrimitive osm, Collection cmds) { + if (Main.pref.getBoolean("cadastrewms.addr.dontUseRelation", false)) { + cmds.add(new ChangePropertyCommand(osm, tagHouseStreet, inputStreet.getText())); + } else if (selectedWay != null) { + Relation selectedRelation = findRelationAddr(selectedWay); + // add the node to its relation + if (selectedRelation != null) { + RelationMember rm = new RelationMember(relationMemberHouse, osm); + Relation newRel = new Relation(selectedRelation); + newRel.addMember(rm); + cmds.add(new ChangeCommand(selectedRelation, newRel)); + } else { + // create new relation + Relation newRel = new Relation(); + newRel.put("type", relationAddrType); + newRel.put(relationAddrName, selectedWay.get(tagHighwayName)); + newRel.addMember(new RelationMember(relationAddrStreetRole, selectedWay)); + newRel.addMember(new RelationMember(relationMemberHouse, osm)); + cmds.add(new AddCommand(newRel)); + } + } + } + + private static Node createNewNode(MouseEvent e, Collection cmds) { + // DrawAction.mouseReleased() but without key modifiers + Node n = new Node(Main.map.mapView.getLatLon(e.getX(), e.getY())); + cmds.add(new AddCommand(n)); + List wss = Main.map.mapView.getNearestWaySegments(e.getPoint(), OsmPrimitive::isSelectable); + Map> insertPoints = new HashMap<>(); + for (WaySegment ws : wss) { + List is; + if (insertPoints.containsKey(ws.way)) { + is = insertPoints.get(ws.way); + } else { + is = new ArrayList<>(); + insertPoints.put(ws.way, is); + } + + is.add(ws.lowerIndex); + } + Set> segSet = new HashSet<>(); + ArrayList replacedWays = new ArrayList<>(); + ArrayList reuseWays = new ArrayList<>(); + for (Map.Entry> insertPoint : insertPoints.entrySet()) { + Way w = insertPoint.getKey(); + List is = insertPoint.getValue(); + Way wnew = new Way(w); + pruneSuccsAndReverse(is); + for (int i : is) { + segSet.add(Pair.sort(new Pair<>(w.getNode(i), w.getNode(i+1)))); + } + for (int i : is) { + wnew.addNode(i + 1, n); + } + cmds.add(new ChangeCommand(insertPoint.getKey(), wnew)); + replacedWays.add(insertPoint.getKey()); + reuseWays.add(wnew); + } + adjustNode(segSet, n); + + return n; + } + + private static void adjustNode(Collection> segs, Node n) { + + switch (segs.size()) { + case 0: + return; + case 2: + // This computes the intersection between + // the two segments and adjusts the node position. + Iterator> i = segs.iterator(); + Pair seg = i.next(); + EastNorth A = seg.a.getEastNorth(); + EastNorth B = seg.b.getEastNorth(); + seg = i.next(); + EastNorth C = seg.a.getEastNorth(); + EastNorth D = seg.b.getEastNorth(); + + double u = det(B.east() - A.east(), B.north() - A.north(), C.east() - D.east(), C.north() - D.north()); + + // Check for parallel segments and do nothing if they are + // In practice this will probably only happen when a way has been duplicated + + if (u == 0) return; + + // q is a number between 0 and 1 + // It is the point in the segment where the intersection occurs + // if the segment is scaled to lenght 1 + + double q = det(B.north() - C.north(), B.east() - C.east(), D.north() - C.north(), D.east() - C.east()) / u; + EastNorth intersection = new EastNorth( + B.east() + q * (A.east() - B.east()), + B.north() + q * (A.north() - B.north())); + + int snapToIntersectionThreshold + = Main.pref.getInteger("edit.snap-intersection-threshold", 10); + + // only adjust to intersection if within snapToIntersectionThreshold pixel of mouse click; otherwise + // fall through to default action. + // (for semi-parallel lines, intersection might be miles away!) + if (Main.map.mapView.getPoint(n).distance(Main.map.mapView.getPoint(intersection)) < snapToIntersectionThreshold) { + n.setEastNorth(intersection); + return; + } + + default: + EastNorth P = n.getEastNorth(); + seg = segs.iterator().next(); + A = seg.a.getEastNorth(); + B = seg.b.getEastNorth(); + double a = P.distanceSq(B); + double b = P.distanceSq(A); + double c = A.distanceSq(B); + q = (a - b + c) / (2*c); + n.setEastNorth(new EastNorth(B.east() + q * (A.east() - B.east()), B.north() + q * (A.north() - B.north()))); + } + } + + static double det(double a, double b, double c, double d) { + return a * d - b * c; + } + + private static void pruneSuccsAndReverse(List is) { + HashSet is2 = new HashSet<>(); + for (int i : is) { + if (!is2.contains(i - 1) && !is2.contains(i + 1)) { + is2.add(i); + } + } + is.clear(); + is.addAll(is2); + Collections.sort(is); + Collections.reverse(is); + } + + private static Cursor getCursor() { + try { + return ImageProvider.getCursor("crosshair", null); + } catch (RuntimeException e) { + Main.warn(e); + } + return Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR); + } + + private void applyInputNumberChange() { + Integer num = Integer.parseInt(inputNumber.getText()); + if (plusOne.isSelected()) + num = num + 1; + if (plusTwo.isSelected()) + num = num + 2; + if (minusOne.isSelected() && num > 1) + num = num - 1; + if (minusTwo.isSelected() && num > 2) + num = num - 2; + inputNumber.setText(num.toString()); + } + + private void revertInputNumberChange() { + Integer num = Integer.parseInt(inputNumber.getText()); + if (plusOne.isSelected()) + num = num - 1; + if (plusTwo.isSelected()) + num = num - 2; + if (minusOne.isSelected() && num > 1) + num = num + 1; + if (minusTwo.isSelected() && num > 2) + num = num + 2; + inputNumber.setText(num.toString()); + } + + private void createDialog() { + ImageIcon iconLink = ImageProvider.get(null, "Mf_relation"); + link.setIcon(iconLink); + link.setEnabled(false); + JPanel p = new JPanel(new GridBagLayout()); + JLabel number = new JLabel(tr("Next no")); + JLabel street = new JLabel(tr("Street")); + p.add(number, GBC.std().insets(0, 0, 0, 0)); + p.add(inputNumber, GBC.eol().fill(GBC.HORIZONTAL).insets(5, 5, 0, 5)); + p.add(street, GBC.std().insets(0, 0, 0, 0)); + JPanel p2 = new JPanel(new GridBagLayout()); + inputStreet.setEditable(false); + p2.add(inputStreet, GBC.std().fill(GBC.HORIZONTAL).insets(5, 0, 0, 0)); + p2.add(link, GBC.eol().insets(10, 0, 0, 0)); + p.add(p2, GBC.eol().fill(GBC.HORIZONTAL)); + clearButton = new JButton("Clear"); + clearButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + inputNumber.setText(""); + inputStreet.setText(""); + setSelectedWay((Way) null); + } + }); + ButtonGroup bgIncremental = new ButtonGroup(); + bgIncremental.add(plusOne); + bgIncremental.add(plusTwo); + bgIncremental.add(minusOne); + bgIncremental.add(minusTwo); + p.add(minusOne, GBC.std().insets(10, 0, 10, 0)); + p.add(plusOne, GBC.std().insets(0, 0, 10, 0)); + tagPolygon.setSelected(Main.pref.getBoolean("cadastrewms.addr.onBuilding", false)); + tagPolygon.addChangeListener(new ChangeListener() { + @Override + public void stateChanged(ChangeEvent arg0) { + Main.pref.put("cadastrewms.addr.onBuilding", tagPolygon.isSelected()); + } + }); + p.add(tagPolygon, GBC.eol().fill(GBC.HORIZONTAL).insets(0, 0, 0, 0)); + p.add(minusTwo, GBC.std().insets(10, 0, 10, 0)); + p.add(plusTwo, GBC.std().insets(0, 0, 10, 0)); + p.add(clearButton, GBC.eol().fill(GBC.HORIZONTAL).insets(0, 0, 0, 0)); + + final Object[] options = {}; + final JOptionPane pane = new JOptionPane(p, + JOptionPane.PLAIN_MESSAGE, JOptionPane.YES_NO_CANCEL_OPTION, + null, options, null); + dialog = pane.createDialog(Main.parent, tr("Enter addresses")); + dialog.setModal(false); + dialog.setAlwaysOnTop(true); + dialog.addComponentListener(new ComponentAdapter() { + protected void rememberGeometry() { + Main.pref.put("cadastrewms.addr.bounds", dialog.getX()+","+dialog.getY()+","+dialog.getWidth()+","+dialog.getHeight()); + } + + @Override public void componentMoved(ComponentEvent e) { + rememberGeometry(); + } + + @Override public void componentResized(ComponentEvent e) { + rememberGeometry(); + } + }); + dialog.addWindowListener(new WindowAdapter() { + @Override + public void windowClosing(WindowEvent arg) { + Main.map.selectMapMode((MapMode) Main.map.getDefaultButtonAction()); + } + }); + String bounds = Main.pref.get("cadastrewms.addr.bounds", null); + if (bounds != null) { + String[] b = bounds.split(","); + dialog.setBounds(new Rectangle( + Integer.parseInt(b[0]), Integer.parseInt(b[1]), Integer.parseInt(b[2]), Integer.parseInt(b[3]))); + } + } + + private void setSelectedWay(Way w) { + this.selectedWay = w; + if (w == null) { + link.setEnabled(false); + } else + link.setEnabled(true); + link.repaint(); + } + + private static void setNewSelection(OsmPrimitive osm) { + DataSet ds = Main.getLayerManager().getEditDataSet(); + Collection newSelection = new LinkedList<>(ds.getSelected()); + newSelection.clear(); + newSelection.add(osm); + ds.setSelected(osm); + } +} Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheControl.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheControl.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheControl.java (revision 33637) @@ -0,0 +1,235 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.concurrent.Callable; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +import javax.swing.JDialog; +import javax.swing.JOptionPane; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.gui.util.GuiHelper; + +/** + * This class handles the WMS layer cache mechanism. The design is oriented for a good performance (no + * wait status on GUI, fast saving even in big file). A separate thread is created for each WMS + * layer to not suspend the GUI until disk I/O is terminated (a file for the cache can take + * several MB's). If the cache file already exists, new images are just appended to the file + * (performance). Since we use the ObjectStream methods, it is required to modify the standard + * ObjectOutputStream in order to have objects appended readable (otherwise a stream header + * is inserted before each append and an exception is raised at objects read). + */ +public class CacheControl implements Runnable { + + public static final String C_LAMBERT_CC_9Z = "CC"; + + public static final String C_UTM20N = "UTM"; + + public static class ObjectOutputStreamAppend extends ObjectOutputStream { + public ObjectOutputStreamAppend(OutputStream out) throws IOException { + super(out); + } + + @Override + protected void writeStreamHeader() throws IOException { + reset(); + } + } + + public static boolean cacheEnabled = true; + + public static int cacheSize = 500; + + public WMSLayer wmsLayer; + + private ArrayList imagesToSave = new ArrayList<>(); + private Lock imagesLock = new ReentrantLock(); + + public boolean isCachePipeEmpty() { + imagesLock.lock(); + boolean ret = imagesToSave.isEmpty(); + imagesLock.unlock(); + return ret; + } + + public CacheControl(WMSLayer wmsLayer) { + cacheEnabled = Main.pref.getBoolean("cadastrewms.enableCaching", true); + this.wmsLayer = wmsLayer; + try { + cacheSize = Integer.parseInt(Main.pref.get("cadastrewms.cacheSize", String.valueOf(CadastrePreferenceSetting.DEFAULT_CACHE_SIZE))); + } catch (NumberFormatException e) { + cacheSize = CadastrePreferenceSetting.DEFAULT_CACHE_SIZE; + } + File path = new File(CadastrePlugin.cacheDir); + if (!path.exists()) + path.mkdirs(); + else // check directory capacity + checkDirSize(path); + new Thread(this).start(); + } + + private static void checkDirSize(File path) { + if (cacheSize != 0) { + long size = 0; + long oldestFileDate = Long.MAX_VALUE; + int oldestFile = 0; + File[] files = path.listFiles(); + for (int i = 0; i < files.length; i++) { + size += files[i].length(); + if (files[i].lastModified() < oldestFileDate) { + oldestFile = i; + oldestFileDate = files[i].lastModified(); + } + } + if (size > (long) cacheSize*1024*1024) { + Main.info("Delete oldest file \""+ files[oldestFile].getName() + + "\" in cache dir to stay under the limit of " + cacheSize + " MB."); + files[oldestFile].delete(); + checkDirSize(path); + } + } + } + + public boolean loadCacheIfExist() { + if (!CadastrePlugin.isCadastreProjection()) { + CadastrePlugin.askToChangeProjection(); + } + File file = new File(CadastrePlugin.cacheDir + wmsLayer.getName() + "." + WMSFileExtension()); + if (file.exists()) { + int reply = GuiHelper.runInEDTAndWaitAndReturn(new Callable() { + @Override + public Integer call() throws Exception { + JOptionPane pane = new JOptionPane( + tr("Location \"{0}\" found in cache.\n"+ + "Load cache first ?\n"+ + "(No = new cache)", wmsLayer.getName()), + JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION, null); + // this below is a temporary workaround to fix the "always on top" issue + JDialog dialog = pane.createDialog(Main.parent, tr("Select Feuille")); + CadastrePlugin.prepareDialog(dialog); + dialog.setVisible(true); + return (Integer) pane.getValue(); + // till here + } + }); + + if (reply == JOptionPane.OK_OPTION && loadCache(file, wmsLayer.getLambertZone())) { + return true; + } else { + delete(file); + } + } + return false; + } + + public void deleteCacheFile() { + delete(new File(CadastrePlugin.cacheDir + wmsLayer.getName() + "." + WMSFileExtension())); + } + + private static void delete(File file) { + Main.info("Delete file "+file); + if (file.exists()) + file.delete(); + while (file.exists()) { // wait until file is really gone (otherwise appends to existing one) + CadastrePlugin.safeSleep(500); + } + } + + public boolean loadCache(File file, int currentLambertZone) { + boolean successfulRead = false; + try ( + FileInputStream fis = new FileInputStream(file); + ObjectInputStream ois = new ObjectInputStream(fis); + ) { + successfulRead = wmsLayer.read(file, ois, currentLambertZone); + } catch (IOException | ClassNotFoundException ex) { + Main.error(ex); + GuiHelper.runInEDTAndWait(new Runnable() { + @Override + public void run() { + JOptionPane.showMessageDialog(Main.parent, tr("Error loading file.\nProbably an old version of the cache file."), + tr("Error"), JOptionPane.ERROR_MESSAGE); + } + }); + return false; + } + if (successfulRead && wmsLayer.isRaster()) { + // serialized raster bufferedImage hangs-up on Java6. Recreate them here + wmsLayer.getImage(0).image = RasterImageModifier.fixRasterImage(wmsLayer.getImage(0).image); + } + return successfulRead; + } + + public synchronized void saveCache(GeorefImage image) { + imagesLock.lock(); + this.imagesToSave.add(image); + this.notifyAll(); + imagesLock.unlock(); + } + + /** + * Thread saving the grabbed images in background. + */ + @Override + public synchronized void run() { + for (;;) { + imagesLock.lock(); + int size = imagesToSave.size(); + imagesLock.unlock(); + if (size > 0) { + File file = new File(CadastrePlugin.cacheDir + wmsLayer.getName() + "." + WMSFileExtension()); + try { + if (file.exists()) { + try (ObjectOutputStreamAppend oos = new ObjectOutputStreamAppend( + new BufferedOutputStream(new FileOutputStream(file, true)))) { + for (int i = 0; i < size; i++) { + oos.writeObject(imagesToSave.get(i)); + } + } + } else { + try (ObjectOutputStream oos = new ObjectOutputStream( + new BufferedOutputStream(new FileOutputStream(file)))) { + wmsLayer.write(file, oos); + for (int i = 0; i < size; i++) { + oos.writeObject(imagesToSave.get(i)); + } + } + } + } catch (IOException e) { + Main.error(e); + } + imagesLock.lock(); + for (int i = 0; i < size; i++) { + imagesToSave.remove(0); + } + imagesLock.unlock(); + } + try { + wait(); + } catch (InterruptedException e) { + Main.error(e); + } + } + } + + private String WMSFileExtension() { + String ext = String.valueOf(wmsLayer.getLambertZone() + 1); + if (CadastrePlugin.isLambert_cc9()) + ext = C_LAMBERT_CC_9Z + ext; + else if (CadastrePlugin.isUtm_france_dom()) + ext = C_UTM20N + ext; + return ext; + } +} Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileLambert4ZoneFilter.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileLambert4ZoneFilter.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileLambert4ZoneFilter.java (revision 33637) @@ -0,0 +1,55 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.io.File; +import java.util.Locale; + +import javax.swing.filechooser.FileFilter; + +public final class CacheFileLambert4ZoneFilter extends FileFilter { + + /** + * Derived from ExtensionFileFilter writen by imi + */ + private final String extension; + private final String description; + + static final CacheFileLambert4ZoneFilter[] filters = { + new CacheFileLambert4ZoneFilter("1", tr("Lambert Zone {0} cache file (.{0})", 1)), + new CacheFileLambert4ZoneFilter("2", tr("Lambert Zone {0} cache file (.{0})", 2)), + new CacheFileLambert4ZoneFilter("3", tr("Lambert Zone {0} cache file (.{0})", 3)), + new CacheFileLambert4ZoneFilter("4", tr("Lambert Zone {0} cache file (.{0})", 4)) + }; + + /** + * Construct an extension file filter by giving the extension to check after. + * + */ + private CacheFileLambert4ZoneFilter(String extension, String description) { + this.extension = extension; + this.description = description; + } + + public boolean acceptName(String filename) { + String name = filename.toLowerCase(Locale.FRANCE); + for (String ext : extension.split(",")) { + if (name.endsWith("." + ext)) + return true; + } + return false; + } + + @Override + public boolean accept(File pathname) { + if (pathname.isDirectory()) + return true; + return acceptName(pathname.getName()); + } + + @Override + public String getDescription() { + return description; + } +} Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileLambert9ZoneFilter.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileLambert9ZoneFilter.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileLambert9ZoneFilter.java (revision 33637) @@ -0,0 +1,60 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.io.File; + +import javax.swing.filechooser.FileFilter; + +public final class CacheFileLambert9ZoneFilter extends FileFilter { + + /** + * Derived from ExtensionFileFilter writen by imi + */ + private final String extension; + private final String description; + + public static CacheFileLambert9ZoneFilter[] filters = { + new CacheFileLambert9ZoneFilter("cc1", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 1)), + new CacheFileLambert9ZoneFilter("cc2", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 2)), + new CacheFileLambert9ZoneFilter("cc3", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 3)), + new CacheFileLambert9ZoneFilter("cc4", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 4)), + new CacheFileLambert9ZoneFilter("cc5", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 5)), + new CacheFileLambert9ZoneFilter("cc6", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 6)), + new CacheFileLambert9ZoneFilter("cc7", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 7)), + new CacheFileLambert9ZoneFilter("cc8", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 8)), + new CacheFileLambert9ZoneFilter("cc9", tr("Lambert CC9 Zone {0} cache file (.CC{0})", 9)) + }; + + /** + * Construct an extension file filter by giving the extension to check after. + * + */ + private CacheFileLambert9ZoneFilter(String extension, String description) { + this.extension = extension; + this.description = description; + } + + public boolean acceptName(String filename) { + String name = filename.toLowerCase(); + for (String ext : extension.split(",")) { + if (name.endsWith("." + ext)) + return true; + } + return false; + } + + @Override + public boolean accept(File pathname) { + if (pathname.isDirectory()) + return true; + return acceptName(pathname.getName()); + } + + @Override + public String getDescription() { + return description; + } + +} Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileUTM20NFilter.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileUTM20NFilter.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CacheFileUTM20NFilter.java (revision 33637) @@ -0,0 +1,55 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.io.File; + +import javax.swing.filechooser.FileFilter; + +public final class CacheFileUTM20NFilter extends FileFilter { + + /** + * Derived from ExtensionFileFilter writen by imi + */ + private final String extension; + private final String description; + + public static CacheFileUTM20NFilter[] filters = { + new CacheFileUTM20NFilter("utm1", tr("Guadeloupe Fort-Marigot cache file (.UTM1)")), + new CacheFileUTM20NFilter("utm2", tr("Guadeloupe Ste-Anne cache file (.UTM2)")), + new CacheFileUTM20NFilter("utm3", tr("Martinique Fort Desaix cache file (.UTM3)")), + new CacheFileUTM20NFilter("utm4", tr("Reunion RGR92 cache file (.UTM4)")) + }; + + /** + * Construct an extension file filter by giving the extension to check after. + * + */ + private CacheFileUTM20NFilter(String extension, String description) { + this.extension = extension; + this.description = description; + } + + public boolean acceptName(String filename) { + String name = filename.toLowerCase(); + for (String ext : extension.split(",")) { + if (name.endsWith("." + ext)) + return true; + } + return false; + } + + @Override + public boolean accept(File pathname) { + if (pathname.isDirectory()) + return true; + return acceptName(pathname.getName()); + } + + @Override + public String getDescription() { + return description; + } + +} Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CadastreGrabber.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CadastreGrabber.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CadastreGrabber.java (revision 33637) @@ -0,0 +1,93 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.URL; + +import javax.imageio.ImageIO; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.io.OsmTransferException; + +public class CadastreGrabber { + + private CadastreInterface wmsInterface = new CadastreInterface(); + + public GeorefImage grab(WMSLayer wmsLayer, EastNorth lambertMin, EastNorth lambertMax) + throws IOException, OsmTransferException { + try { + URL url = null; + if (wmsLayer.isRaster()) + url = getURLRaster(wmsLayer, lambertMin, lambertMax); + else + url = getURLVector(lambertMin, lambertMax); + BufferedImage img = grab(url); + if (img == null) + throw new OsmTransferException(url.toString()); + ImageModifier imageModified; + if (wmsLayer.isRaster()) + imageModified = new RasterImageModifier(img); + else + imageModified = new VectorImageModifier(img, false); + return new GeorefImage(imageModified.getBufferedImage(), lambertMin, lambertMax, wmsLayer); + } catch (MalformedURLException e) { + throw (IOException) new IOException(tr("CadastreGrabber: Illegal url.")).initCause(e); + } + } + + private static URL getURLRaster(WMSLayer wmsLayer, EastNorth lambertMin, EastNorth lambertMax) throws MalformedURLException { + // GET /scpc/wms?version=1.1&request=GetMap&layers=CDIF:PMC@QH4480001701&format=image/png&bbox=-1186,0,13555,8830&width=576&height=345&exception=application/vnd.ogc.se_inimage&styles= HTTP/1.1 + final int cRasterX = CadastrePlugin.imageWidth; // keep width constant and adjust width to original image proportions + String str = CadastreInterface.BASE_URL+"/scpc/wms?version=1.1&request=GetMap"; + str += "&layers=CDIF:PMC@"; + str += wmsLayer.getCodeCommune(); + str += "&format=image/png"; + //str += "&format=image/jpeg"; + str += "&bbox="; + str += wmsLayer.eastNorth2raster(lambertMin, lambertMax); + str += "&width="+cRasterX+"&height="; // maximum allowed by wms server (576/345, 800/378, 1000/634) + str += (int) (cRasterX*(wmsLayer.communeBBox.max.getY() - wmsLayer.communeBBox.min.getY())/(wmsLayer.communeBBox.max.getX() - wmsLayer.communeBBox.min.getX())); + str += "&exception=application/vnd.ogc.se_inimage&styles="; // required for raster images + Main.info("URL="+str); + return new URL(str.replace(" ", "%20")); + } + + private static URL buildURLVector(String layers, String styles, + int width, int height, + EastNorth lambertMin, EastNorth lambertMax) throws MalformedURLException { + String str = CadastreInterface.BASE_URL+"/scpc/wms?version=1.1&request=GetMap"; + str += "&layers="+ layers; + str += "&format=image/png"; + str += "&bbox="+lambertMin.east()+","; + str += lambertMin.north() + ","; + str += lambertMax.east() + ","; + str += lambertMax.north(); + str += "&width="+width+"&height="+height; + str += "&exception=application/vnd.ogc.se_inimage"; // works also without (but slower ?) + str += "&styles=" + styles; + Main.info("URL="+str); + return new URL(str.replace(" ", "%20")); + } + + private static URL getURLVector(EastNorth lambertMin, EastNorth lambertMax) throws MalformedURLException { + return buildURLVector(CadastrePlugin.grabLayers, CadastrePlugin.grabStyles, + CadastrePlugin.imageWidth, CadastrePlugin.imageHeight, + lambertMin, lambertMax); + } + + private BufferedImage grab(URL url) throws IOException, OsmTransferException { + try (InputStream is = wmsInterface.getContent(url)) { + return ImageIO.read(is); + } + } + + public CadastreInterface getWmsInterface() { + return wmsInterface; + } +} Index: /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CadastreInterface.java =================================================================== --- /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CadastreInterface.java (revision 33637) +++ /applications/editors/josm/plugins/cadastre-fr/src/org/openstreetmap/josm/plugins/fr/cadastre/CadastreInterface.java (revision 33637) @@ -0,0 +1,607 @@ +// License: GPL. For details, see LICENSE file. +package org.openstreetmap.josm.plugins.fr.cadastre; + +import static org.openstreetmap.josm.tools.I18n.tr; + +import java.awt.GridBagLayout; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.net.CookieHandler; +import java.net.HttpURLConnection; +import java.net.MalformedURLException; +import java.net.URISyntaxException; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.List; + +import javax.swing.JComboBox; +import javax.swing.JDialog; +import javax.swing.JOptionPane; +import javax.swing.JPanel; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.data.validation.util.Entities; +import org.openstreetmap.josm.gui.layer.Layer; +import org.openstreetmap.josm.gui.progress.NullProgressMonitor; +import org.openstreetmap.josm.gui.util.GuiHelper; +import org.openstreetmap.josm.io.OsmTransferException; +import org.openstreetmap.josm.io.ProgressInputStream; +import org.openstreetmap.josm.tools.GBC; + +public class CadastreInterface { + public boolean downloadCanceled; + private HttpURLConnection urlConn; + + private String cookie; + private String interfaceRef; + private String lastWMSLayerName; + private URL searchFormURL; + private List listOfCommunes = new ArrayList<>(); + private List listOfTA = new ArrayList<>(); + static class PlanImage { + String name; + String ref; + PlanImage(String name, String ref) { + this.name = name; + this.ref = ref; + } + } + + private List listOfFeuilles = new ArrayList<>(); + private long cookieTimestamp; + + static final String BASE_URL = "https://www.cadastre.gouv.fr"; + static final String C_IMAGE_FORMAT = "Cette commune est au format "; + static final String C_COMMUNE_LIST_START = " + * + * + * + * + * The returned string is the interface name used in further requests, e.g. "afficherCarteCommune.do?c=QP224" + * where QP224 is the code commune known by the WMS (or "afficherCarteTa.do?c=..." for raster images). + * + * @return retURL url to available code commune in the cadastre; "" if not found + */ + private String postForm(WMSLayer wmsLayer, String codeCommune) throws IOException { + try { + listOfCommunes.clear(); + listOfTA.clear(); + // send a POST request with a city/town/village name + String content = "numerovoie="; + content += "&indiceRepetition="; + content += "&nomvoie="; + content += "&lieuDit="; + if (codeCommune.isEmpty()) { + content += "&ville=" + java.net.URLEncoder.encode(wmsLayer.getLocation(), "UTF-8"); + content += "&codePostal="; + } else { + content += "&codeCommune=" + codeCommune; + } + content += "&codeDepartement="; + content += wmsLayer.getDepartement(); + content += "&nbResultatParPage=10"; + content += "&x=0&y=0"; + searchFormURL = new URL(BASE_URL + "/scpc/rechercherPlan.do"); + urlConn = (HttpURLConnection) searchFormURL.openConnection(); + urlConn.setRequestMethod("POST"); + urlConn.setDoOutput(true); + urlConn.setDoInput(true); + setCookie(); + try (OutputStream wr = urlConn.getOutputStream()) { + wr.write(content.getBytes(StandardCharsets.UTF_8)); + Main.info("POST "+content); + wr.flush(); + } + String ln; + StringBuilder sb = new StringBuilder(); + try (BufferedReader rd = new BufferedReader(new InputStreamReader(urlConn.getInputStream(), StandardCharsets.UTF_8))) { + while ((ln = rd.readLine()) != null) { + sb.append(ln); + } + } + String lines = sb.toString(); + urlConn.disconnect(); + if (lines != null) { + if (lines.indexOf(C_IMAGE_FORMAT) != -1) { + int i = lines.indexOf(C_IMAGE_FORMAT); + int j = lines.indexOf('.', i); + wmsLayer.setRaster("image".equals(lines.substring(i+C_IMAGE_FORMAT.length(), j))); + } + if (!wmsLayer.isRaster() && lines.indexOf(C_INTERFACE_VECTOR) != -1) { // "afficherCarteCommune.do" + // shall be something like: interfaceRef = "afficherCarteCommune.do?c=X2269"; + lines = lines.substring(lines.indexOf(C_INTERFACE_VECTOR), lines.length()); + lines = lines.substring(0, lines.indexOf('\'')); + lines = Entities.unescape(lines); + Main.info("interface ref.:"+lines); + return lines; + } else if (wmsLayer.isRaster() && lines.indexOf(C_INTERFACE_RASTER_TA) != -1) { // "afficherCarteTa.do" + // list of values parsed in listOfFeuilles (list all non-georeferenced images) + lines = getFeuillesList(); + if (!downloadCanceled) { + parseFeuillesList(lines); + if (!listOfFeuilles.isEmpty()) { + int res = selectFeuilleDialog(); + if (res != -1) { + wmsLayer.setCodeCommune(listOfFeuilles.get(res).name); + checkLayerDuplicates(wmsLayer); + interfaceRef = buildRasterFeuilleInterfaceRef(wmsLayer.getCodeCommune()); + wmsLayer.setCodeCommune(listOfFeuilles.get(res).ref); + lines = buildRasterFeuilleInterfaceRef(listOfFeuilles.get(res).ref); + lines = Entities.unescape(lines); + Main.info("interface ref.:"+lines); + return lines; + } + } + } + return null; + } else if (lines.indexOf(C_COMMUNE_LIST_START) != -1 && lines.indexOf(C_COMMUNE_LIST_END) != -1) { + // list of values parsed in listOfCommunes + int i = lines.indexOf(C_COMMUNE_LIST_START); + int j = lines.indexOf(C_COMMUNE_LIST_END, i); + parseCommuneList(lines.substring(i, j)); + } + } + } catch (MalformedURLException e) { + throw (IOException) new IOException("Illegal url.").initCause(e); + } catch (DuplicateLayerException e) { + Main.error(e); + } + return null; + } + + private void parseCommuneList(String input) { + if (input.indexOf(C_OPTION_LIST_START) != -1) { + while (input.indexOf("