First release of experimental PDF renderer

Author: systemed

README.txt

@@ -0,0 +1,40 @@
+MapPDF - Ruby map PDF renderer
+==============================
+
+This is an experimental PDF renderer from MapCSS stylesheets.
+
+== Dependencies ==
+
+* Jochen Topf's OSMlib (http://osmlib.rubyforge.org/)
+* Prawn (http://prawn.majesticseacreature.com/)
+* Ruby MapCSS parser (https://github.com/systemed/mapcss_ruby)
+* RQuad (https://github.com/iterationlabs/rquad)
+
+NOTE: current Prawn will not work perfectly. You need a slight patch to lib/prawn/images.rb - 
+see comments in lib/pdf_renderer/point_item.rb. You'll still get a map without this patch, 
+but the icons will be offset.
+
+== How to use ==
+
+See pdf_test.rb. In short:
+
+1. (OSMlib)      Read your OSM data into a database
+2. (mapcss_ruby) Create a 'parent objects' dictionary
+3. (mapcss_ruby) Read the MapCSS file into a RuleSet
+4. (mappdf_ruby) Create a MapSpec with the bounding box and map area parameters
+5. (Prawn)       Create a PDF
+6. (mappdf_ruby) Tell the MapSpec to draw onto it
+
+== To do ==
+
+* Dashes for casing
+* Dash decoration
+* Better text offset
+* Bold, italic, underline
+* Labels for areas
+
+== Licence and author ==
+
+WTFPL. You can do whatever the fuck you want with this code. Code by Richard Fairhurst, autumn 2011.
+
+OpenStreetMap data by OpenStreetMap contributors (CC-BY-SA).

charlbury.osm

@@ -0,0 +1,14 @@
+module PDFRenderer #:nodoc:
+  VERSION = "0.1"
+end
+
+require "pdf_renderer/display_list"
+require "pdf_renderer/map_spec"
+require "pdf_renderer/drawing_item"
+require "pdf_renderer/casing_item"
+require "pdf_renderer/stroke_item"
+require "pdf_renderer/text_item"
+require "pdf_renderer/fill_item"
+require "pdf_renderer/point_item"
+require "pdf_renderer/canvas_item"
+require "pdf_renderer/collision_object"

icons/parking_cycle.png

@@ -0,0 +1,12 @@
+module PDFRenderer
+	class CanvasItem < DrawingItem
+		
+		def draw(pdf, spec)
+			pdf.fill_color(sprintf("%06X",@style.get(@tags,'fill_color')))
+			pdf.transparent(@style.get(@tags,'fill_opacity',1).to_f) do
+				pdf.rectangle [spec.boxoriginx, spec.boxoriginy],spec.boxwidth,-spec.boxheight
+				pdf.fill
+			end
+		end
+	end
+end

icons/pub.png

@@ -0,0 +1,28 @@
+module PDFRenderer
+	class CasingItem < DrawingItem
+		
+		def draw(pdf, spec)
+			pdf.line_width=@style.get(@tags,'width').to_f + @style.get(@tags,'casing_width').to_f
+			defaultcap = @style.get(@tags,'linecap')
+			defaultjoin= @style.get(@tags,'linejoin')
+			pdf.cap_style=case @style.get(@tags,'casing_linecap')
+				when 'none'		then :butt
+				when 'square'	then :projecting_square
+				when 'round'	then :round
+				else			(defaultcap ? defaultcap : :butt)
+			end
+			pdf.join_style=case @style.get(@tags,'casing_linejoin')
+				when 'miter'	then :miter
+				when 'bevel'	then :bevel
+				when 'round'	then :round
+				else			(defaultjoin ? defaultjoin : :round)
+			end
+			pdf.stroke_color(sprintf("%06X",@style.get(@tags,'casing_color')))
+			# do dash with pdf.stroke_dash or implement separately
+			# etc.
+			StrokeItem.draw_line(pdf, spec, @entity)
+			pdf.stroke
+		end
+		
+	end
+end

lib/pdf_renderer.rb

@@ -0,0 +1,28 @@
+module PDFRenderer
+	class CollisionObject
+
+		attr_accessor	:left, :right, :top, :bottom, :item, :sub_id
+		
+		def initialize(x,y,xradius,yradius,item=nil,sub_id=nil)
+			@left  =x-xradius
+			@right =x+xradius
+			@top   =y+yradius
+			@bottom=y-yradius
+			@item   =item
+			@sub_id =sub_id
+		end
+
+		def collides_with(cx,cy,cxradius,cyradius)
+			cleft  =cx-cxradius
+			cright =cx+cxradius
+			ctop   =cy+cyradius
+			cbottom=cy-cyradius
+			((cleft >@left && cleft <@right) ||
+			 (cright>@left && cright<@right) ||
+			 (cleft <@left && cright>@right)) &&
+			((cbottom>@bottom && cbottom<@top) ||
+			 (ctop   >@bottom && ctop   <@top) ||
+			 (cbottom<@bottom && ctop   >@top))
+		end
+	end
+end

lib/pdf_renderer/canvas_item.rb

@@ -0,0 +1,119 @@
+module PDFRenderer
+	class DisplayList
+
+		attr_accessor	:rules, :spec
+		
+		def initialize(rules,spec)
+			@rules=rules
+			@spec=spec
+			@list=[]
+		end
+		
+		def compile_way(way)
+			# ** calculate midpoint and length
+			pathlength=0
+
+			# Get tags
+			tags = TagsBinding.new(way)
+			if (way.is_closed?) then tags[':area']='yes' end
+
+			# Get stylelist
+			stylelist=@rules.get_styles(way, tags, @spec.scale)
+			layer = parse_layer(stylelist, tags)
+			
+			# ** Do multipolygon stuff
+			
+			# Add entry for each subpart
+			stylelist.subparts.each do |subpart|
+				if stylelist.shapestyles[subpart] then
+					s=stylelist.shapestyles[subpart]
+					filled=(s.defined('fill_color') || s.defined('fill_image'))	# ** multipolygon stuff
+
+					if s.defined('width')		 then add_item(layer, StrokeItem.new(s, way, tags)) end
+					if filled					 then add_item(layer, FillItem.new(s, way, tags)) end
+					if s.defined('casing_width') then add_item(layer, CasingItem.new(s, way, tags)) end
+				end
+				if stylelist.textstyles[subpart] then
+					add_item(layer, TextItem.new(stylelist.textstyles[subpart], way, nil, tags, pathlength))
+				end
+			end
+		end
+		
+		def compile_poi(node)
+			dictionary=StyleParser::Dictionary.instance
+
+			# Get tags
+			tags = TagsBinding.new(node)
+			if !dictionary.has_parent_ways(node) then tags[':poi']='yes'
+			elsif dictionary.num_parent_ways(node)>1 then tags[':junction']='yes' end
+			# ** do hasInterestingTags
+			
+			# Find style
+			stylelist=@rules.get_styles(node, tags, @spec.scale)
+			layer = parse_layer(stylelist,tags)
+
+			# Add entry for each subpart
+			stylelist.subparts.each do |subpart|
+				pointitem = nil
+				if stylelist.pointstyles[subpart] then
+					pointitem=PointItem.new(stylelist.pointstyles[subpart], 
+					                        stylelist.shapestyles[subpart], node, tags)
+					add_item(layer, pointitem)
+				end
+				if stylelist.textstyles[subpart] then
+					add_item(layer, TextItem.new(stylelist.textstyles[subpart], node, pointitem, tags))
+				end
+			end
+		end
+		
+		def compile_canvas
+			stylelist=@rules.get_styles(nil, {}, spec.scale)
+			stylelist.subparts.each do |subpart|
+				if stylelist.shapestyles[subpart] then
+					add_item(@spec.minlayer, CanvasItem.new(stylelist.shapestyles[subpart], nil))
+				end
+			end
+		end
+		
+		def add_item(layer,item)
+			sublayer=item.get_sublayer
+			l=layer-@spec.minlayer
+			
+			if !@list[l] then @list[l]=[] end
+			if !@list[l][sublayer] then @list[l][sublayer]=[] end
+			@list[l][sublayer]<<item
+		end
+		
+		def draw(pdf)
+			for layer in 0..(@list.length-1)
+				if @list[layer] then
+					draw_items_of_class(pdf,@list[layer],CanvasItem)
+					draw_items_of_class(pdf,@list[layer],FillItem)
+					draw_items_of_class(pdf,@list[layer],CasingItem)
+					draw_items_of_class(pdf,@list[layer],StrokeItem)
+					draw_items_of_class(pdf,@list[layer],PointItem)
+					draw_items_of_class(pdf,@list[layer],TextItem)
+				end
+			end
+		end
+		
+		def draw_items_of_class(pdf, items, itemclass)
+			items.each do |sublayer_items|
+				if sublayer_items then
+					sublayer_items.each do |item|
+						if item.instance_of?(itemclass) then item.draw(pdf,@spec) end
+					end
+				end
+			end
+		end
+
+		# -----	Get layer (may come from override in declarations, or from layer tag)
+			
+		def parse_layer(stylelist,tags)
+			layer=stylelist.layer_override
+			if layer.nil? and tags.has_key?('layer') then layer=[[tags['layer'].to_i,@spec.minlayer].max,@spec.maxlayer].min end
+			layer.nil? ? 0 : layer
+		end
+
+	end
+end

lib/pdf_renderer/casing_item.rb

@@ -0,0 +1,14 @@
+module PDFRenderer
+	class DrawingItem
+
+		def initialize(style, entity, tags=nil)
+			@entity=entity
+			@style=style
+			@tags=tags ? tags : (entity ? entity.tags : {} )
+		end
+		
+		def get_sublayer
+			@style.sublayer
+		end
+	end
+end

lib/pdf_renderer/collision_object.rb

@@ -0,0 +1,22 @@
+module PDFRenderer
+	class FillItem < DrawingItem
+		
+		def draw(pdf, spec)
+			dictionary=StyleParser::Dictionary.instance
+			return if dictionary.is_member_of(@entity,'multipolygon','inner')
+			multipolygons=dictionary.parent_relations_of_type(@entity,'multipolygon','outer')
+			
+			pdf.fill_color(sprintf("%06X",@style.get(@tags,'fill_color')))
+			pdf.transparent(@style.get(@tags,'fill_opacity',1).to_f) do
+				StrokeItem.draw_line(pdf, spec, @entity)
+				multipolygons.each do |multi|
+					dictionary.relation_loaded_members(@entity.db,multi,'inner').each do |obj|
+						if obj.type=='way' then StrokeItem.draw_line(pdf, spec, obj) end
+					end
+				end
+				pdf.add_content("f*")	# like pdf.fill, but for even-odd winding
+			end
+		end
+		
+	end
+end