What’s new with JavaScript and geospatial – wrapup from the js.geo event
My brain is overflowing at the end of the two days, and I have lots of things I want to look into more. This post is mainly a list of items I found interesting with some links. Apologies in advance to anyone / anything I missed out! Without further ado …
D3
D3 is a very cool general purpose JavaScript interactive visualization library, developed by Mike Bostock, that includes some good (mainly vector) geospatial capabilities. This was probably the hottest topic at the conference, lots of people talking about it and incorporating it into demos. Here’s a blog post from CartoDB with some examples. D3 supports a new format calledTopoJSON, which is similar to geoJSON, but supports topology to eliminate redundancy. For polygon data this can reduce data volumes by around 80% (compared to regular geoJSON). It also lends itself to robust simplification of polygons.
LEAFLET
Several presentations, including this one by Aaron Ogle, confirmed the impression I had that the Leaflet JavaScript mapping API has great momentum. Matt Priour in his presentation on OpenLayers acknowledged as much with his pitch that OpenLayers was “almost as convenient as Leaflet and twice as powerful”. One of the key selling points of Leaflet is its simplicity. Matt said that in discussions about OpenLayers 3 there were proponents of just moving to adopt Leaflet instead of doing a major redevelopment of OpenLayers, but it was decided for various reasons that OpenLayers 3 was needed – you can see further discussion on its aims here. It’s important to be aware that OpenLayers 3 will not be compatible with OpenLayers 2, it’s going to be a fresh start. We are looking seriously at using Leaflet for a future version of our Ubisense myWorld application.
CARTODB
I continue to be very impressed with CartoDB. They first launched the product at FOSS4G in Denver in 2011, and released Version 2 in November 2012, with lots of cool new features. These include a new system called Torque which does beautiful spatio-temporal visualizations, and new density maps using either hexagons or squares. I definitely plan to work on including CartoDB in the solutions that we’re offering. Check out Andrew Hill’s presentation.
MAPSTRACTION
Andrew Turner gave a lightning talk about Mapstraction, a library that provides an abstraction layer for the major mapping APIs. Last time I looked at this I had the impression it wasn’t being very actively developed, but it seems I was misinformed! This is something I want to investigate further too. There’s a nice sandbox demo site here.
MAPBOX
The folks at MapBox also continue to do a whole range of interesting things, from their TileMill map rendering product to a range of map sharing tools at Mapbox.com to their iPad application. A little while ago I did a simple demo with some utility data using various bits of MapBox infrastructure, borrowing heavily from this example (you’ll probably need a browser other than Internet Explorer for these to work). As well as giving a workshop, Will White talked about their server side architecture which uses node.js (JavaScript on the server).
UBISENSE MYWORLD
I did a short presentation and demo on what we’re up to with Ubisense myWorld, building web applications for utilities and telecoms using Google Maps and various open source products. I’ll do a longer post soon on what we’ve been up to recently, but we got some good interest in what we’ve done with Google Street View, including the overlay of linear objects like gas pipes, and also in work we did to help a customer with recovery efforts after Hurricane Sandy. Thanks to Steve Citron-Pousty for his summary:
WEBGL
Brendan Kenny from Google gave an interesting talk on WebGL, which brings high performance 3D (and 2D) graphics to (most) web browsers (no prizes for guessing which one is the main exception!). He did a really impressive demo that involved displaying very large numbers of points in the browser with dynamic charts based on the current map window and dynamic filtering tools.
MISCELLANEOUS OTHER LINKS
In no particular order …
npm is “Node Packaged Modules” which was highly recommended by Will White for managing either server side or client side JavaScript Code.
openweathermap.org is a cool resource for free and open weather data.
Backbone.js and Marionette.js, which builds on top of Backbone, were highly recommended by Dave Bouwman as frameworks for building complex JavaScript applications. I definitely plan to look more at these for what we’re doing. Ember.js was also mentioned as an alternative.
Max Ogden’s geoJSON utilities got several mentions, a lightweight JavaScript library that supports some core spatial operations like point in polygon, distance and more on geoJSON data.
The Google Visualization API looks like a nice library for visualizing data tables and charts.
PhantomJS is a headless webkit browser that is useful for various things including browser screen capture and testing. This blog post talks about using it to implement a web map printing tool. Alfred Sawatzky talked about how he used this to capture periodic screen shots of his company iFactor’s outage maps during the Hurricane Sandy recovery.
Rickshaw.js is a JavaScript toolkit for creating interactive time series graphs.
The ESRI CityEngine Web Viewer is a cool application for viewing 3D city models in a browser without any plugins. You can see various examples here, press the play button at the bottom left for an automated tour of a model. This one in Philadelphia is impressive.
Simtable are doing interesting things with projecting animated data onto 3D models.
MongoDB is a scalable open source NoSQL database that provides geospatial support – up until now just for points, but about to have support for any geoJSON geometry and operations like point in polygon etc. Steve Citron-Pousty ran a workshop on this which I would have liked to have gone to, but I went to the MapBox / CartoDB one instead.
So, lots of things to research and absorb!!
Update: Tyler Burgett also shared some excellent detailed notes, and Steve C-P has posted agood summary too.
*)
val _ = Control.polyEqWarn := false;
val _ = let
(* utility *)
fun printResults(results) = foldl (fn ((module, report), _) => print(module ^ ":\n" ^ report ^ "\n")) () results
fun allStringsEqual str strs = foldl (fn (nextStr, allEqualSoFar) => allEqualSoFar andalso nextStr = str) true strs
fun onlyFailedModules results =
List.map
(fn (module, result) => (module, foldl (op ^) "" result))
(List.filter (fn (_, result) => (not o (allStringsEqual "")) result) results)
(* assertion framework *)
fun assert(msg: string, e: bool) = if e then "" else "\tFAIL: " ^ msg ^ "\n"
fun assertFalse(msg: string, e: bool) = assert(msg, not e)
fun assertEquals(msg, expected, result) = assert("expected " ^ msg, expected = result)
fun assertEqualsInt(msg, expected, result) =
assertEquals("int " ^ Int.toString(expected) ^ " but was " ^ Int.toString(result) ^ " - " ^ msg, expected, result)
fun assertEmptyList(msg, xs) = assert("expected empty list - " ^ msg, null xs)
fun assertEqualsList(msg, expected, result) = assertEquals("equal lists - " ^ msg, expected, result)
fun assertEqualsString(msg, expected, result) =
assertEquals("string '" ^ expected ^ "' but was '" ^ result ^ "' - " ^ msg, expected, result)
fun assertNone(msg: string, result) = assert("expected NONE but got SOME - " ^ msg, not (isSome result))
fun assertSome(msg, expected) = assert("expected SOME but got NONE - " ^ msg, isSome(expected))
(* tests *)
(* TODO: should implement `test` runner (only feasible with some kind of lazy evaluation scheme) *)
(* (also setup/teardown functions, number of tests run, ...) *)
(* consider passing the function to be tested as a parameter just once, to avoid *)
(* having to repeat the function name all the time *)
(* find out if SML allows the code to find out a function name as a string, to avoid *)
(* having to pass the `test` function both as a symbol and as a string *)
val tests = [
("only_capitals", [
assertEmptyList("for empty list", only_capitals([])),
assertEqualsList("for list with uppercase strings", ["Upper", "Case"],
only_capitals(["lower", "case", "Upper", "Case"])
)
]),
("longest_string1", [
assertEqualsString("for 'longest' as the first of many longest strings",
"longest", longest_string1(["short", "small", "longest", "tiny", "l0ng3st"]))
]),
("longest_string2", [
assertEqualsString("for 'l0ng3st' as the last of many longest strings",
"l0ng3st", longest_string2(["short", "small", "longest", "tiny", "l0ng3st"]))
]),
("longest_string_helper", let
fun like_in_longest_string_1(x, y) = x > y
in [
assertEqualsString("for 'longest' as the first of many longest strings",
"longest", longest_string_helper like_in_longest_string_1 ["short", "small", "longest", "tiny", "l0ng3st"])
] end),
("first_answer", [
assert("should raise NoAnswer for empty list",
(* NOTE: sort of tedious construct to `test` for the right kind of exception to be raised *)
(* maybe figure out a more elegant way *)
(* trivial, if lazy evaluation is possible in any way *)
case SOME(SOME(first_answer (fn x => NONE) [])) handle NoAnswer => NONE | _ => SOME(NONE) of
NONE => true
| SOME _ => false
),
assertEqualsInt("for equals_3 on increasing list", 3,
first_answer (fn x => case x of 3 => SOME 3 | _ => NONE) [1, 2, 3, 4, 5]
)
]),
("all_answers", [
assertEquals("for any f and empty list", SOME [], all_answers (fn x => x) []),
assertNone("for x => NONE and any list", all_answers (fn x => NONE) [1, 2, 3, 4, 5]),
assertEqualsList("for x => SOME [x, x*x] and an int list", SOME [2, 4, 5, 25, 3, 9, 4, 16],
all_answers (fn x => SOME [x, x*x]) [2, 5, 3, 4]
)
]),
("count_wildcards", [
assertEqualsInt("for tuple of Wildcard patterns", 3,
count_wildcards (TupleP [Wildcard, ConstP 3, Wildcard, UnitP, Wildcard]))
]),
("check_pat", [
assertFalse("for repeated Variable name", check_pat (TupleP [Variable "my_var", Variable "my_var"])),
assertFalse("for repeated Variable names with other patterns interspersed",
check_pat(TupleP [Variable "my_var", UnitP, Wildcard, Variable "my_var"])
),
assert("for non-repeated Variables names with other patterns interspersed",
check_pat (TupleP [Variable "my_var", UnitP, Wildcard, Variable "other_var"])
)
]),
("match", [
assertEquals("empty binding list for Wildcard pattern", SOME [], match(Const 16, Wildcard)),
assertEquals("one binding for matching pattern with one Variable", SOME [("my_var", Const 13)],
match(Const 13, Variable "my_var")
),
assertEquals("empty binding list for matching UnitP", SOME [], match(Unit, UnitP)),
assertEquals("empty binding list for matching ConstP", SOME [], match(Const 17, ConstP 17)),
assertEquals("binding list for matching ConstructorP", SOME [("my_var", Const 13)],
match(Constructor("my_constructor", Const 13), ConstructorP("my_constructor", Variable "my_var"))
),
assertEquals("binding list for matching TupleP", SOME [("my_var", Const 13), ("other_var", Const 17)],
match(Tuple [Const 13, Const 17], TupleP [Variable "my_var", Variable "other_var"])
)
]),
("first_match", [
assertEquals("empty binding list for Wildcard pattern", SOME [],
first_match (Const 16) [UnitP, Wildcard, Variable "my_var"]
),
assertEquals("one binding for Variable pattern", SOME [("my_var", Const 16)],
first_match (Const 16) [UnitP, Variable "my_var", Wildcard]
),
assertNone("for no matching pattern",
first_match (Const 16) [UnitP, ConstP 32, ConstructorP ("my_constructor", Variable "my_var")]
)
]),
("typecheck_patterns", [
assertEquals("Anything-TupleT for first hw-example",
SOME (TupleT [Anything, Anything]),
typecheck_patterns([], [TupleP [Variable "x", Variable "y"], TupleP [Wildcard, Wildcard]])),
assertEquals("nested Anything-TupleT for second hw-example",
SOME (TupleT [Anything, TupleT [Anything, Anything]]),
typecheck_patterns([], [TupleP [Wildcard, TupleP [Wildcard, Wildcard]], TupleP [Wildcard, Wildcard]])),
assertNone("for exception UnmatchedConstructor",
typecheck_patterns([], [
TupleP [Wildcard, TupleP [Wildcard, Wildcard]],
TupleP [Wildcard, Wildcard],
TupleP [ConstructorP("my_cons", Variable "my_var"), Wildcard]
])),
assertEquals("TupleT with Datatype for example with valid Constructor",
SOME (TupleT [Datatype "c_my_type", TupleT [Anything, Anything]]),
typecheck_patterns([("my_cons", "c_my_type", IntT)], [
TupleP [Wildcard, TupleP [Wildcard, Wildcard]],
TupleP [Wildcard, Wildcard],
TupleP [ConstructorP("my_cons", ConstP 13), Wildcard]
]))
])
]
val _ = print "\n\n";
in
case onlyFailedModules tests of
[] => print("SUCCESS\n\n")
| results => printResults(results)
end
, :y
def initialize(x,y)
@x = x
@y = y
end
def eval_prog env
self # all values evaluate to self
end
def preprocess_prog
self # no pre-processing to do here
end
def shift(dx,dy)
Point.new(@x + dx, @y + dy) # shifting a point
end
def intersect other
other.intersectPoint self
end
def intersectPoint p
if real_close_point(@x, @y, p.x, p.y)
Point.new(p.x, p.y)
else
NoPoints.new
end
end
def intersectLine line
if real_close(@y, line.m * @x + line.b)
Point.new(@x, @y)
else
NoPoints.new
end
end
def intersectVerticalLine vline
if real_close(@x, vline.x)
Point.new(@x, @y)
else
NoPoints.new
end
end
def intersectWithSegmentAsLineResult seg
if (inbetween(@x,seg.x1,seg.x2) and inbetween(@y,seg.y1,seg.y2)) then
Point.new(@x,@y)
else
NoPoints.new
end
end
end
class Line < GeometryValue
# *add* methods to this class -- do *not* change given code and do not
# override any methods
attr_reader :m, :b
def initialize(m,b)
@m = m
@b = b
end
def eval_prog env
self # all values evaluate to self
end
def preprocess_prog
self # no pre-processing to do here
end
def shift(dx,dy)
Line.new(@m, @b + dy - @m*dx) # shifting a line
end
def intersect other
other.intersectLine self
end
def intersectPoint p
p.intersectLine self
end
def intersectLine line
if real_close(@m, line.m) then
if real_close(@b, line.b) then
Line.new(@m, @b)
else
NoPoints.new
end
else
x = (line.b - @b) / (@m - line.m)
y = @m * x + @b
Point.new(x, y)
end
end
def intersectVerticalLine vline
Point.new(vline.x, @m * vline.x + @b)
end
def intersectWithSegmentAsLineResult seg
#Line.new(@m, @b)
LineSegment.new(seg.x1,seg.y1,seg.x2,seg.y2)
end
end
class VerticalLine < GeometryValue
# *add* methods to this class -- do *not* change given code and do not
# override any methods
attr_reader 
In this assignment, you will create a data type that resizes a W-by-H image using the seam-carving technique.
The energy is high (white) for pixels in the image where there is a rapid color gradient (such as the boundary between the sea and sky and the boundary between the surfing Josh Hug on the left and the ocean behind him). The seam-carving technique avoids removing such high-energy pixels.
