I made inverse solutions for all my invented projections, and even threw
in a new one, "Tetrachamfer", which kind of sucks, but I felt like I
should include it for completeness's sake. I found a bug in
MapConfigurationDialog and squashed it, as well. And I added a couple
new maps to the output folder. Oh, I never explained what the problem
with Tobler was! There was an issue with the way Z was being generated,
so last commit, I cleaned that up and may have made it slightly slower,
but I don't really care given how well it works now and how much faster
it still is than Lee (seriously, what is the deal with that?). Did I do
anything else? Not really. Next step: conic projections!
I just added a standard parallel slider to Tobler. I think it's much
better this way. It'll give the optimizer more room to play. I think
this is a good thing.
I got the labels to move around when you resize the graph, and changed
up my distortion metrics slightly. I was, like, yeah. This is good. Now
I can optimize my Tobler projection. And then I found out that the map
optimizer was assigning Tobler size distortions of .4! I'm just so
confused. So that's completely broken. I suppose once I figure this out,
it might help to explain why Tetrapower is so bad.
And that's before optimization. I have two variables to play with. And
it's pseudocylindrical. Who would've thought? Tobler, I guess.
This binary search thing worked out super well; I'm really happy with
it. I didn't even have to touch Newton's method, which I think
contributes to this being faster than Winkel Tripel. I must admit, the
code is not pretty by any stretch of the word. But it works. Really
well. I'm so happy right now.
I spent a buttload of time working on the Tobler projection. It is now
unbearably slow and still has an average distortion of, like .04. It's
okay, though. I've got a plan to fix both of those problems. It involves
ordinary differential equations and inheritance. Nyeh heh heh heh heh!
All map-based Applications have been changed to make use of
MapApplication. Yay. I also fixed equal-area cylindrical to be real. Now
if only Tobler and the conic maps were real.
I added more inheritance. When I think of the word "inheritance", the
first thing that comes to mind is the above quote. It's from one of the
broadsheet articles in The Bands of Mourning. Actually, most of what I
did in this commit had to do with parametrization, not inheritance. Oh,
well. It's a good quote.
Maps can have parameters now. Woo. It's an opportunity that Equal-Area
Cylindrical (very simple), my made-up map projections (not that hard a
leap), and Winkel Tripel (surprisingly difficult) currently take
advantage of. I still need to make the conic projections be
parametrized, and Tobler once I can make it be real. I also still need
to make MapAnalyzer take advantage of this newfound inheritance.
That was... a lot. I decided to put some inheritance into the project,
and what a rabbit hole that turned out to be!
Huh. I think that may be the first time I've ever actually used an
"exclamatory statement". What a useless structure that is!
Anyway, both MapDesigners now inherit from the same abstract super
class. Eventually, I'll get MapAnalyzer to link to that, too. I also
changed a whole lot of other things, and started inserting parametric
map capacities. That should be a fun GUI thing to figure out. I also
changed a lot of other things that I can't remember off the top of my
head. I've just been dragging chunks of code around and swimming in
errors for the past week.
I had been under the impression that there wasn't one. If so, I'm
apparently a cartographic genius. More likely I was just mislead by that
2002 Turkish paper.
I made a new program to plot existing map projections with labels (I
have yet to actually add the labels). I also moved some things around,
implemented Aitoff, and found a bug in my Newton-Raphson Approximation
that was making it converge slower (how it still managed to converge to
the right value is totally beyond me).
I implemented the Tobler projection using values from Tobler's paper,
Numerical Approaches to Map Projections and spline interpolation. I used
the apache commons' cubic spline solution, which felt kind of like
cheating, but splines are way more complicated to solve for than I
thought, so I don't feel that bad.
It's also not actually equal-area, so not sure what's up with that. I'll
probably go looking for an iterative solution to try to deal with that.
Either way, this is a great projection.
I also move some methods and classes around.
I refactored everything (assuming I actually understand what the word
'refactoring' means, which I think I do, but I'm not sure. I'm too lazy
to check). There are fewer duplicate names, corresponding information is
closer together in general, the code has less redundancy, it's easier to
add new map projections, and classes are grouped more effectively and
more logically. I've now switched from using Strings to represent map
projections to using an enum (remember when I was using separate
classes? Wow, that was trash!). I was also going to combine the
MapDesigners and MapAnalyzer with some inheritance type stuff, but I
think that's content for another commit.
