DEV Community: Ian Turton

Drawing a line on a GeoTools Map using Java Swing

Ian Turton — Mon, 08 May 2023 00:00:00 +0000

As anyone following the dismal news out of the UK recently will know we had some sort of royal extravaganza down south in England this weekend, so with nothing better to do (and an extra day off) I decided to do some playing with GeoTools. This was mostly motivated by the work I had already done in answering this gis.stackexchange.com question about how to draw a line on top of a map. It seems that there isn’t much about how to do this in the GeoTools documentation.

So I scratched my head and dredged up what I could remember about swing and particularly about the GeoTools swing module and came up with some code that answered the immediate question which was why the OP got many layers in the map rather than one. I decided that this might be useful for other people so I tidied the code up and created a small project that contains a DigitizerAction and a Digitizer class which is the actual tool. It’s pretty simple all it does is place a series of dots on the screen and then generates a LineString which is added to a list, which is then used to generate a new FeatureLayer and removes the old layer (if it exists).

I finished up by adding a little demo program which adds a draw button to the toolbar and displays the US States for you to draw over.

All you do is click the draw button, then each click on the map will add a point to the current line, a double click finishes the line and forces a redraw of the screen with the line now in red.

Details

For anyone who’s trying to create a new tool for their swing application with GeoTools here is a little more on how it works.

Action

We need to create an Action to tell swing what we plan to do, I called mine DigitizerAction and made it extend MapAction which Michael Bedward (the original author of the gt-swing module) helpfully provided to save us typing (or pasting) in a lot of boiler plate code. All I have to provide is some code to initialise the action’s icon, name etc and an actionPerformed method to set the tool up to actually do something when the button is clicked.

Tool

Again to save time and effort the Digitizer tool extends CursorTool which extends MapMouseAdapter so we don’t need to worry about how to listen to the mouse’s movements or how to get a real world position from a mouse click. Much of the code is either set up or book keeping. For set up we need to generate a FeatureType for the Features we’ll be building later, and a style so they show up on the map (a more advanced tool might let the user override that default style). The only other thing to take care of in the constructor is setting the cursor to a simple cross hair.

   public Digitizer() {
        SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
        b.setName("LineFeature");
        b.add("line", LineString.class);
        SimpleFeatureType TYPE = b.buildFeatureType();
        featureBuilder = new SimpleFeatureBuilder(TYPE);
        geometryFactory = JTSFactoryFinder.getGeometryFactory(JTSFactoryFinder.EMPTY_HINTS);
        style = SLD.createLineStyle(Color.red, 2.0f);

        ImageIcon imgIcon = new ImageIcon(getClass().getResource(ICON_IMAGE));
        cursor = new Cursor(Cursor.CROSSHAIR_CURSOR);
    }

The class also has some fields that we’ll need later lastX and lastY which is the position of the last click, an ArrayList of Coordinates which are the real world positions of the current line, and a list of SimpleFeatures which hold the lines that we have already drawn. We need to keep track of the previous features as the display layer is recreated every time we add a line.

The actual interaction with the user all occurs inside the onMouseClicked method which is called each time a mouse button is clicked.

    public void onMouseClicked(MapMouseEvent e) {

        if (e.getClickCount() > 1) { // was it a double click
            drawTheLine(positions);
            first = true;
        } else { // add a new point
            DirectPosition2D pos = e.getWorldPos();

            positions.add(new Coordinate(pos.x, pos.y));
            // Put a marker at each digitized point
            Graphics graphics = (Graphics2D) ((JComponent) getMapPane()).getGraphics().create();
            int x = e.getX();
            int y = e.getY();
            if (!first) {
                graphics.drawLine(lastX, lastY, x, y);
            }
            first = false;
            lastX = x;
            lastY = y;
            graphics.fillRect(x - 3, y - 3, 6, 6);
        }
    }

Here we first check if the user has clicked twice within the system time limit (so it is a double click), if it is we call the drawTheLine method on the positions list to add the line to the screen, we’ll look at that in a moment. We also reset the first flag to say that the next click (if there is one) is the first in a line.

If the user only clicked once (or this is the first click of a double click) we will go through the else branch, where we get the world position of the click and add that to our list of coordinates. We then grab a graphics from our map pane to draw a temporary mark so the user knows we’re listening and have seen their click, here we need the X and Y pixel coordinates. If this is not the first point in the line we draw a line from the last point (lastX, lastY) to the current point (x, y) and then we draw a point at the current point (x, y). We also make a note of this point for next click to be the start of the line and note that we now have previous point by making first false.

The last remaining step is to draw lines on the map as SimpleFeatures, this is done in drawTheLine where we generate a new LineString using the GeometryFactory, we then add that LineString to the FeatureBuilder and create a new SimpleFeature from it. Note that we leave the id set to null so it generates a new FID for each feature. The feature is then stored in the features list, the existing layer is removed from the map (to prevent us ending up with an ever increasing number of map layers). Then we create a new FeatureLayer using the DataUtilities.collection method to convert our list of SimpleFeatures to a SimpleFeatureCollection and applying the style we made earlier. Finally, we reset the positions list to empty to be ready to store the next line for the user.

Usage

If you want to use this in your own map you can simply do the following:

    mapFrame = new JMapFrame();
    mapFrame.enableToolBar(true);
    JToolBar toolBar = mapFrame.getToolBar();
    DigitizerAction d = new DigitizerAction(mapFrame.getMapPane());
    JButton btn = new JButton(d);
    toolBar.addSeparator();
    toolBar.add(btn);

You can then get the list of features by using d.getFeatures() if you want to provide a save function or to send them to some other store.

Some interesting books I've read recently

Ian Turton — Mon, 04 Jul 2022 00:00:00 +0000

Interesting Books

This is a short post to let you know about some interesting books I’ve recently finished that you might find interesting.

The Atlas of Unusual Borders

Or to give it its full title The Atlas of Unusual Borders: Discover intriguing boundaries, territories and geographical curiosities by Zoran Nikolic. I blame Barry Rowlingson who threw a link to it into a twitter discussion on borders, so I had to buy it. And, to be honest I’m very happy I did, it is an atlas of “interesting” border enclaves and other geographic oddities. So if like me you’ve ever wondered why Belgium has some many enclaves (and exclaves, and counter-enclaves) (or you just wondered what those are) this is the book that you need in your library. It also answers questions such as which capital city is a ghost town too? Plymouth, Montserrat to save you trying to look it up. This is a fascinating book with nearly every page leading to a “I didn’t know that”. My only minor quibble with it is the colour scheme of the maps, I really struggle with maps where the land is blue and the sea is grey, and with the highlights as yellow it is probably not a book for anyone with blue/yellow colour blindness.

git commit murder and git sync murder

This pair of books by Michael Warren Lucas, are murder mysteries set at technical conferences. If you have ever been to an open source conference (such as FOSS4G) then you will recognise many of the characters in these books. In the first book set at the (fictional) BSDNorth conference our hero Dale Whitehead sets out to give a technical talk but is sidetracked by the death of his room mate (and the weight of his laptop bag, which he seems to never get around to clearing out). I found this a very believable account of free software development, technical conferences and Unix hackers, though while I may have considered killing a user I’ve never actually done it!

git sync murder sees Dale forced to attend another conference despite his promise to himself to never leave his apartment ever again. Once again, things quickly spin out of his control and that laptop bag is no lighter than last time. I loved both these books and can thoroughly recommend them if you are at all into whodunits.

Finally, if you enjoy conferences/convention books then I’ll throw in Charlie Stross’ Dechlorinating the Moderator which I read in his collected Toast volume which reports from a futuristic 2018 Particulate 7: HiNRG & B-OND conference, for a fun short story.

Open Source and Sanctions

Ian Turton — Fri, 11 Mar 2022 00:00:00 +0000

Some Thoughts On Open Source Programs and Sanctions

To start this post first let me state that this represents my personal view and may or may not be the view of any of the projects I mention and that I completely and utterly condemn the Russian invasion of Ukraine.

In the last 2 weeks since Russia invaded Ukraine I have been seeing a number of tweets and other comments that a) ESRI should pull out of Russia and invalidate the licences it has sold in the country, and b) (usually from different people) what about the open source community? Should they ban downloads from Russia.

TL;DR : I’m firmly on the side of no, there is nothing open source programs and communities can do to prevent people they don’t like using their code to do things they don’t approve of.

If you’re still reading then let me lay out some of my thinking, again this makes more sense if you remember that I’m old so I’ve seen most of these discussions in some form or another before. I can remember when the open source community went to court in the USA to try to determine that code was free speech as at the time it was illegal to export “munitions” in the form of encryption software from the USA. Interestingly we are still seeing remnants of this in (for example) Oracle’s JDK and JDBC libraries. There is a certain arrogance to this sort of blocking moves. It screams (at least to me) “We Americans are so smart no puny European (or North Korean or …) can program like we do!” But I don’t think that’s true and I have worked with a lot of European, Russian, and other nationality programmers over the years and I have never noticed that they are in any way dumber than the Americans I’ve worked with. So I think that banning countries from downloading programs is a stupid idea, also it’s very hard to do well and make actually work in a world with easy VPNs. And does any one really think that say North Korea will be defeated by a click through licence that asks them not to do something.

So in the abstract I don’t think banning will work, in the case of open source software it is doubly impossible because we don’t even know how many users we have or where they are or even who is distributing our code. As Jáchym Čepický said on twitter:

You do not understand the concept of open source software do you? Nobody can block the software to be downloaded and used for any purpose - even if it was evil. As community member, you can refuse support, you can cancel some other members. But nobody really “owns” the software.

I’ve watched some of the other FOSS4G communities discuss this (often at some length) and essentially come to the same conclusion. QGis decided to put a notice in the News Tab of the new release, and someone promptly complained that they didn’t want “politics” in their software, Leaflet changed it’s home page to make clear their concerns for Vladimir Agafonkin who started the project 11 years ago and has been forced to leave his home in Ukraine due to the invasion. These are both great responses and I fully support them, GeoServer and GeoTools haven’t done anything similar, partly because no one raised the issue and partly because making a statement will not actually change anything, so I’d rather donate money to charities supporting Ukrainian refugees such as the https://savelife.in.ua/en/donate/ charity, or the Ukrainian Red Cross, where it will actually make life (marginally) better for someone.

Finally, this leads us to the old argument from the “postmodern geographers” (that I left academia to avoid) who always felt that GIS was a tool of the military industrial complex and so could never be used for good. To which I’ve always said so what, many things I use in every day life were developed by the military (or for the military), there is a reason for that the military has an almost unlimited budget (when did you last see a collection tin for a new tank rather than a new MRI machine?) so they can spend absurd amounts of money on research and development. More than once I’ve been happy to take that money and use it to develop open source computer programs that all of humanity can use (and prevent them buying more explosive toys with the cash instead). Does that mean I have blood on my hands when the UK Army uses (say) GeoServer to plan it’s deployments in Afghanistan? Or would it have been worse if I hadn’t cooperated and they had used another map server or just paper maps. Am I concerned to learn that North Korea uses GeoServer, GeoTools and PostGIS? In both cases no, I am happy that we have another satisfied user and I hope they contribute back but like most of our users I expect to never hear from them once.

In conclusion, there is no way for anyone to truly block access to open source software, in fact that is rather the point of open source software, and if there was a way to block people there is every chance that a government somewhere would object to me (or my country) or something about me to block my use of some software.

How does contributing to open source work (for me)?

Ian Turton — Sun, 26 Sep 2021 00:00:00 +0000

Recently, we have been on boarding some new staff at Astun (where I work) and one of the questions that seems to keep coming up is “how does open source work?” So I’ve been giving a bit more thought to how and why I contribute to open source projects than I usually do, and whether open source is sustainable in this way.

Some history

You have to remember that I’m old (really old in computing terms) such that when I started out if you wanted software on your Unix computer you compiled it yourself from open sources or wrote it yourself. There was of course some provided code on the machine after all you needed to use Sun’s cc to compile gcc so you could compile everything else you needed. Linux was just starting to be available when I started my first job but most of our work was done on Sun workstations. As I was working at a university (during the Thatcher years) the big draw of open source code was the cost (free) but over time I also came to appreciate the value of being able to look at the source code to see how a program worked so I could either write something similar or fix the problem I had found. I found my first compiler bug while I was working on my PhD and fortunately could print out that piece of code to take to the support team to show them why it was wrong.

When we completed the program I was developing in that first job I released it under the GNU Public Licence (GPL). Partly because it was too hard to work out who owned it - the university (my employer) who claimed to own anything I wrote or the ESRC (the funder) who also claimed to own anything I wrote when funded by them. I could foresee spending time in small offices talking to lawyers if we tried to commercialise it, and that didn’t appeal.

During the next few years, James Macgill and I started writing and collecting useful bits of Java code into what became GeoTools version 1. Again we gave the code away under the GPL, partly for the same reasons as before but mostly so we could help other people produce repeatable science. We likened computational geography to (say) chemistry before commercial glass ware became available - your experiment might fail to replicate someone’s results not because their results were wrong but because you had built the apparatus wrong. We felt (and still do) that if the only way to check someone’s paper was to drop thousands of pounds (or dollars) on a copy of Arc/Info then that was a problem (and how could we know there were no bugs in Arc/Info). So we encouraged others to take our code and check it, extend it and pass it on to other users, in then hope that better science would be produced.

Along the way we came across the Open Geospatial Consortium (OGC) and the web map test bed which fitted nicely with some work I was involved in on the public participation in planning which needed maps on the web (though in those days we still had to take computers out to the public to get useful numbers of users). We also met Chris Holmes and Rob Hranac of the Open Planning Project who were also working on this sort of thing. From those meetings GeoServer was born, again we all benefited from access to other open source code and again released the project under the GPL to encourage reuse and contributions.

Overtime we pulled in code such as Seagis or built on top of other open source code such as JTS. We also added support for a variety of new data sources in a plugable way that allowed others to add just the bits of code they needed.

Next year sees the 20th anniversary of GeoTools version 2 and the project is still progressing nicely.

Contributing

A lot of my job is now providing training and support to users of GeoServer (along with QGIS and other open source geospatial projects). Some of that “support” time is used to maintain the bits of GeoServer and GeoTools that are not actually fun (security updates and other technical debt). In my other working day of the week (when I freelance) I help out people who would like some custom GeoTools code written. For example, the ability to specify which transform you’d like to use when converting to and from a coordinate reference system (GEOT-6920) was funded by the Tanzanian Ministry of Home Affairs. And finally in my spare time I write code that interests me, there are many sources of ideas:

The GeoTools and GeoServer issue trackers are often fertile places to search.
GeoTools questions on gis.stackexchange.com are always likely too.
Other questions I see around on twitter.

Basically though something has to sound interesting for me to spend my limited free time on it. After all I don’t have a lot of free time to program and I really want to spend that time having fun (or I could be doing something else that is fun instead). The only other thing that motivates me is that some bug (or lack of feature) is embarrassing, for example I recently finished off Jody’s work that allows GeoServer administrators see which modules and extensions are loaded in their version. Every time we went to this page when I was running a GeoServer course I would have to explain why this page didn’t actually show all the extensions (including the one we had just added) and there was really no go reason other than lack of time (and funding) so I just sat down and fixed the remaining modules (except the community ones, you are still on your own there). This means that the next GeoServer course will be slightly more fun for me to do (provided I’ve updated to 2.20.x).

So recently “projects” have been adding some functionality to GeoTools that I was interested in such as contouring point layers. I had always wondered how it was done, and GeoTools currently couldn’t do it and I had the whole of the christmas holiday to play. I’ve also recently had a look at how to maintain topologically correct borders between polygons when simplifying them. This came from a question on gis.stackexchange and again turned out to be an interesting problem that is probably useful for many users. The latest project is looking at adding a label line along the centre of a polygon. In asking for more help on this problem I’ve found that MapServer is trying to add this functionality too (so now it’s a race). In the time this blog post has been languishing part written I’ve managed to finish this up (the answer is to use Dijkstra to find the longest shortest path between nodes of index 1).

So, I now have a much better handle on how JTS works (for some functions anyway) and more respect for topology than I used to. I think that next I might try to look at some problems that don’t require me to read up on graphs. The obvious next step is to package up the code with some unit tests, push it in the GeoTools code base and then add something to the GeoServer manual so that other people can use them. I promise I will get around to that some time (if you would like me to do it urgently then please get it touch and I can talk you through the process or give up a price).

If you would like to know more of how I (and Andrea) spend our time please come and watch our talk at FOSS4G 2021 (it’s this Wednesday at 13:00UTC).

Beginners Python Books

Ian Turton — Fri, 02 Oct 2020 00:00:00 +0000

Beginners Python Books

I recently found my self with some time to kill (you don’t have to watch the Tour De France that closely) and as I had a Python for QGIS course coming up for the first time in a year I thought I could use some revision. I’m not a “native” python writer (lack of types while liberating is also scary to a Java boy like me), so brushing up on my Python seemed like a good idea. I had recently bought two new Python books from Manning. Tiny Python Projects by Ken Youens-Clark and Python Workout by Reuven M. Lerner and this was an ideal opportunity to read through them.

Tiny Python Projects

Tiny Python Projects comes as a series of 22 chapters where you build a new program against a set of unit tests that the author provides via a git repository. They start off simple hello world program and building through strings, lists and dictionaries. Then adding functions (and testing functions) to algorithms and regular expressions to finish up with a working tic-tac-toe (noughts and crosses) game. I found this book great fun to read and in the later chapters to code along to as well. The emphasis on test driven development is, I think, a really useful process for new programmers to get used to. All to often I see students (and others) who write some code and hope that it works but often never check it (in some cases ever). If I’ve learnt anything in the 30 odd years I’ve been coding it’s that without a test that code is worthless, if only because when you come back to it the test will remind you how to run it if nothing else. One of the things that seems to upset new contributors to GeoServer and GeoTools is our insistence on a test case before we start to look into their issue, the trouble is that with no test how can we know if we fixed your problem. So any book which helps to instil this understanding of the necessity of testing in new coders is great.

The topics covered a wide ranging and while often silly (e.g. spotting animals from the crows nest) they cover a good depth of python topics and I think a new python programmer could easily teach themselves how to produce complex (and correct) programs to could do useful work from this book. If you plan to go on to use Python in a specific domain then there would almost certainly be new modules and packages that you would want to explore and learn but this book would give you the grounding that you’d need to understand the documentation and examples that this would lead to.

Python Workout

Python Workout’s subtitle is 50 ten-minute exercises, and this gives you a flavour of the book’s contents. As it sounds each chapter is a single exercise with discussion on the “best” solution and why it is in the author’s opinion the best way of solving it. There are also videos of the author solving each problem which some might find useful as it does give an insight into the way that the solution is developed. Most of the chapters also provide a link to Python Tutor which allows you to step through some python code and see what happens as each line is executed. This tool is new to me but I think I will be looking at adding it to my teaching in the future.

Again the topics covered in Python Workout start at simple numbers, strings, lists, dictionaries before more complex functions, functional programming with comprehensions, modules and packages and finishing up with creating your own iterators and generators. There is something here for everyone from beginners to experienced python programmers, and it is all nicely packaged up to give you a daily workout. The style is less formal that Tiny Python Projects with less emphasis on writing tests to make sure you have solved the problem but with more discussion on how to approach solving the problem.

Conclusions

Both of these books would be a great introduction to python to new programmers, and for programmers who are converting from another language. They provide a clear introduction to the language and the features that make python different from (or the same as) other languages, and take you through to the complex features that make programming with python fun (and challenging).

At first sight the books might seem expensive but Manning produce very nice well made physical and electronic books and you get the source code too. If you by the physical book you get the e-book for free where ever you buy it so you can save on shipping by ordering it locally. Also if it looks expensive today, wait a day or two and Manning will almost certainly be having a 40% off sale, or a buy one get one free week or some other deal, I don’t think I have ever paid full price for one of their books.

How I made writing my code journal easier

Ian Turton — Tue, 07 Apr 2020 08:32:07 +0000

Liquid syntax error: 'raw' tag was never closed

Speeding up like queries in PostGIS (and GeoServer)

Ian Turton — Wed, 04 Apr 2018 00:00:00 +0000

I often use like queries in PostGIS and with GeoServer into a PostGIS datastore. But recently a trainee on course asked if they were fast enough to allow them to use in a CQL query to allow the end user to generate new layers on the fly.

After some Googling we discovered that they probably are but that there are a few tricks you need to use to get the benefits of the index.

I had always indexed any attribute (column) that I intended to use in the styling of a layer or that would be queried in requests. But it turns out that might not be good enough if you are making like queries.

To test this out I’m using the Ordnance Survey open data Vector Map Districtdataset for the whole of Great Britain, it’s large but not enormous. For example the roads table has 2.8 million road segments of which 800 thousand are named. Here is the “default” index.

CREATE INDEX idx_distinictive_name
  ON vmd.road
  USING btree
  (distinctivename COLLATE pg_catalog."default");

So, I ran a typical query to find how many roads are named after some sort of Oak tree:

select distinctivename, count(ogc_fid) 
from vmd.road 
where distinctivename
like '%oak%' 
group by distinctivename order by count desc;

On my desktop machine this takes 162 milliseconds to run, which is not too bad but it could probably be better. If we look at the query plan:

Sort (cost=83988.80..83988.97 rows=67 width=21)
  Sort Key: (count(ogc_fid)) DESC
  -> Finalize GroupAggregate (cost=83978.87..83986.77 rows=67 width=21)
      Group Key: distinctivename
      -> Gather Merge (cost=83978.87..83985.82 rows=56 width=21)
          Workers Planned: 2
          -> Partial GroupAggregate (cost=82978.84..82979.33 rows=28 width=21)
              Group Key: distinctivename
              -> Sort (cost=82978.84..82978.91 rows=28 width=17)
                    Sort Key: distinctivename
                    -> Parallel Seq Scan on road (cost=0.00..82978.17 rows=28 width=17)
                          Filter: ((distinctivename)::text ~~'%oak%'::text)

There is no mention of an index! Wow! I’d never really checked on this before so this was a bit of a shock. So after a bit of strategic googling I found thisstackoverflow question and answer, which recommended that I add the pg_trgm extension so that I had GIN and GiST trigram indexes that support all like and ilike patterns.

CREATE EXTENSION pg_trgm

CREATE INDEX idx_distinictive_name2
  ON vmd.road
    USING gin
      (distinctivename COLLATE pg_catalog."default" gin_trgm_ops);

Now the query takes a mere 20 milliseconds and the query plan looks a lot better with an index in use front and centre:

Sort (cost=284.30..284.47 rows=67 width=21)
  Sort Key: (count(ogc_fid)) DESC
  -> GroupAggregate (cost=281.10..282.27 rows=67 width=21)
        Group Key: distinctivename
        -> Sort (cost=281.10..281.26 rows=67 width=17)
              Sort Key: distinctivename
              -> Bitmap Heap Scan on road (cost=16.52..279.07 rows=67 width=17)
                    Recheck Cond: ((distinctivename)::text ~~'%oak%'::text)
                    -> Bitmap Index Scan on idx_distinictive_name2 (cost=0.00..16.50 rows=67 width=0)
                          Index Cond: ((distinctivename)::text ~~'%oak%'::text)

All of these speed ups are passed directly to GeoServer when you are using a PostGIS datastore as these queries are passed down to the database to handle. So it pays to make sure you have not just indexed an attribute but that you are using the right index for the type of queries you expect to see.

For the larger Vector Map Local data using ILIKE since the Ordnance Survey used all caps for the road names, the speed up is from 760ms to 122ms.

Finding anagrams of place names (in GB)

Ian Turton — Wed, 20 Dec 2017 00:00:00 +0000

A little while ago Alasdair Rae asked if any one had combined an anagram engine with a list of place names.

Well, no one stepped forward so I thought it could be a fun project. And, it turns out it is quite fun though I got to think about data structures rather more than geography, but that is probably good for me.

I made the assumption that Alasdair was probably not interested in just permutations of letters but wanted actual words (such as would be used in a crossword clue). I also limited my search to single word anagrams as I can’t see a simple solution to finding multi word solutions.

First I stuffed the Ordnance Survey’s OpenNames data set into PostGIS (as who wants to be scanning hundreds of little csv files).

I then set up a GeoTool’s PostGIS datastore and grabbed the populated places.

Map<String, Object> params = new HashMap<String, Object>();
    params.put(PostgisNGDataStoreFactory.DBTYPE.key, PostgisNGDataStoreFactory.DBTYPE.sample);
    params.put(PostgisNGDataStoreFactory.USER.key, "username");
    params.put(PostgisNGDataStoreFactory.PASSWD.key, "password");
    params.put(PostgisNGDataStoreFactory.SCHEMA.key, "opennames");
    params.put(PostgisNGDataStoreFactory.DATABASE.key, "osdata");
    params.put(PostgisNGDataStoreFactory.HOST.key, "127.0.0.1");
    params.put(PostgisNGDataStoreFactory.PORT.key, "5432");

      DataStore ds = DataStoreFinder.getDataStore(params);
    if (ds == null) {
      throw new RuntimeException("No datastore");
    }
    SimpleFeatureSource fs = ds.getFeatureSource("opennames");
    SimpleFeatureCollection features = fs.getFeatures(CQL.toFilter("type = 'populatedPlace'"));

I tried a naive approach of recursively finding every anagram possible from the name and looking each one up in a HashMap of English words. Oddly, this took a long time so I thought (and Googled) some more and came up with the much more efficient way of sorting the letters in a word and using that as a key to all words that contained those letters. Then I could sort each place name’s letters and do a single lookup to find all the possible words that could be made with those letters. That speeded things up nicely.

To build the lookup table I made use of Google’s HashMultimap (fromGuava) which allows you to create a Map ofCollections keyed on a String.

private Map<String, Collection<String>> dict;

  public AnagramLookup() throws FileNotFoundException, IOException {
    //change this to point to your dictionary (one word per line)
    File f = new File("/usr/share/dict/british-english");
    HashMultimap<String, String> indexedDictionary = HashMultimap.create();
    try (BufferedReader buf = new BufferedReader(new FileReader(f))) {
      String line;
      // read each word in the dictionary
      while ((line = buf.readLine()) != null) {
        //strip out non letters
        String word = line.toLowerCase().replaceAll("\\W", "");
        //store the word against the sorted key
        indexedDictionary.put(sort(word), word);
      }
    }
    dict = indexedDictionary.asMap();
  }

Then all that is left to do is to iterate each populated place, grab it’s name and then remove all the non-letters and sort it’s letters and look the anagrams in the HashMap. The final trick is to remove the name itself if it appears in the list of anagrams (i.e. the name itself is an English word).

try (SimpleFeatureIterator itr = features.features()) {

      while (itr.hasNext()) {

        SimpleFeature f = itr.next();
        String name = (String) f.getAttribute("name1");

        current = name.toLowerCase().replaceAll("\\W", "");
        Collection<String> anagrams = getAnagrams(current);

        if(anagrams!=null && !anagrams.isEmpty()) {
          //remove the name itself if it happens to be a word
          anagrams.remove(current);
          if(!anagrams.isEmpty()) {
            results.put(name, new TreeSet<String>(anagrams));
          }
        }
      }
    }

Results

It turns out that there are 6 11 letter anagrams for the list of GB place names.

Balnadelson - belladonnas
Fortis Green - reforesting
Gilling East - legislating
Green Plains - spenglerian
Morningside - modernising
Sharrington - harringtons
Stone Corner - cornerstone

A Spenglerian is “of or relating to the theory of world history developed by Oswald Spengler which holds that all major cultures undergo similar cyclical developments from birth to maturity to decay”. While aHarrington is “a man’s short lightweight jacket with a collar and a zipped front.”

Other highlights for crossword setters include Aimes Green as menageries and Westlinton as tinseltown.

I have posted the full list of anagrams and the code to generate the list.

See this follow up for world names.