module Mapkick::Helper

Public Instance Methods

bubble_radius(bubbles, bubble, min_radius, max_radius) click to toggle source
# File lib/mapkick/helper.rb, line 180
def bubble_radius(bubbles, bubble, min_radius, max_radius)
        bubbles_radius = bubbles.map{|b| b[:radius].to_i}
        min = bubbles_radius.min
        max = bubbles_radius.max
        rad = bubble[:radius].to_i
        per = (rad - min) / (max - min).to_f
        per * (max_radius - min_radius).floor + min_radius
end
buckets(data, bucket_count) click to toggle source
# File lib/mapkick/helper.rb, line 150
def buckets(data, bucket_count)
        min = data.values.min
        max = data.values.max
        range = max - min
        per_bucket = range.to_f / bucket_count
        bucket_starts = []
        (min..max).step(per_bucket) do |n|
                bucket_starts << n.ceil
        end
        bucket_ranges = []
        bucket_starts.each_with_index do |bs, i|
                if i > 0
                        start = bucket_starts[i-1]
                        finish = bucket_starts[i] - 1
                        finish += 1 if i == bucket_starts.length - 1
                        bucket_ranges << "#{start} - #{finish}"
                end
        end
        bucket_ranges
end
color(data, obj_index, colors) click to toggle source
# File lib/mapkick/helper.rb, line 171
def color(data, obj_index, colors)
        obj_val = data[obj_index]
        min = data.values.min
        max = data.values.max
        per = (obj_val - min) / (max - min).to_f
        color_index = [(per * colors.length).floor, colors.length - 1].min
        colors[color_index]
end
mapkick_map(scope, data = {}, options = {}) click to toggle source
# File lib/mapkick/helper.rb, line 11
                def mapkick_map(scope, data = {}, options = {})
                        @mapkick_map_id ||= 0
                        options = options.dup
                        # HTML options
                        element_id = options.delete(:id) || "map_#{@mapkick_map_id += 1}"
                        styles = options.delete(:styles) || "style='position: relative;'"
                        # Map Options
                        projection = options.delete(:projection) || "equirectangular"
                        fills = options.delete(:fills) || ['#fcc','#f99','#f66','#f33','#f00']
                        defaultFill = options.delete(:defaultFill) || "#ccc"
                        events = options.delete(:events) || []
                        # Geo options
                        geo_options = options.delete(:geo) || {}
                        geo_popupTemplate = geo_options.delete(:popupTemplate) || "'<strong>' + geo.properties.name + '<br/><center>' + data.numberOfThings + '</center></strong>'"
                        geo_hideAntarctica = geo_options.delete(:hideAntarctica) || true
                        geo_borderWidth = geo_options.delete(:borderWidth) || 1
                        geo_borderColor = geo_options.delete(:borderColor) || '#FDFDFD'
                        geo_popoverOnHover = geo_options.delete(:popoverOnHover) || true
                        geo_highlightOnHover = geo_options.delete(:highlightOnHover) || true
                        geo_highlightFillColor = geo_options.delete(:highlightFillColor) || '#FC8D59'
                        geo_highlightBorderColor = geo_options.delete(:highlightBorderColor) || 'rgba(250, 15, 160, 0.2)'
                        geo_highlightBorderWidth = geo_options.delete(:highlightBorderWidth) || 2
                        # Bubble options
                        bubbles = options.delete(:bubbles) || []
                        bubble_options = options.delete(:bubble) || {}
                        bubble_maxRadius = bubble_options.delete(:maxRadius) || 50
                        bubble_minRadius = bubble_options.delete(:minRadius) || 10
                        bubble_popup = bubble_options.delete(:popup) || "data.name"
                        bubble_borderWidth = bubble_options.delete(:borderWidth) || 2
                        bubble_borderColor = bubble_options.delete(:borderColor) || '#FFFFFF'
                        bubble_popupOnHover = bubble_options.delete(:popupOnHover) || true
                        bubble_fillOpacity = bubble_options.delete(:fillOpacity) || 0.75
                        bubble_highlightOnHover = bubble_options.delete(:highlightOnHover) || true
                        bubble_highlightFillColor = bubble_options.delete(:highlightFillColor) || '#FC8D59'
                        bubble_highlightBorderColor = bubble_options.delete(:highlightBorderColor) || 'rgba(250, 15, 160, 0.2)'
                        bubble_highlightBorderWidth = bubble_options.delete(:highlightBorderWidth) || 2
                        bubble_highlightFillOpacity = bubble_options.delete(:highlightFillOpacity) || 0.85
                        # Legend options
                        show_legend = options.delete(:show_legend) || false

                        js_fills = ["defaultFill: '#{defaultFill}'"]
                        if data.count > 0
                                fill_buckets = buckets(data, fills.count)
                                fills.each_with_index do |fill, i|
                                        js_fills << "'#{fill_buckets[i]}': '#{fill}'"
                                end
                        end

                        state_data = []
                        data.each_pair do |key, val|
                                state_data << "#{key}: {fillKey: '#{fill_buckets[color(data, key, (0...fills.length).to_a)]}', numberOfThings: #{data[key]}}"
                        end

                        events.map! do |event|
                                "datamap.svg.selectAll('.datamaps-subunit').on('#{event[:type]}', function(geography) {
                                        #{event[:event]}
                                })"
                        end

                        js_bubbles = bubbles.map do |bubble|
                                bubble[:radius] = bubble_radius(bubbles, bubble, bubble_minRadius, bubble_maxRadius)
                                bubble_data = []
                                bubble.each_pair do |key, val|
                                        if [Fixnum, Float].include?(val.class)
                                                bubble_data << "#{key}: #{val}"
                                        else
                                                bubble_data << "#{key}: '#{val}'"
                                        end
                                end
                                "{#{bubble_data.join(',')}}"
                        end

                        html = <<-HTML
                                <div id="#{element_id}" #{styles}></div>
                        HTML

                        js = <<-JS
                                <script type="text/javascript">
                                        $(function(){
                                                var map_#{element_id} = new Datamap({
                                                        element: document.getElementById("#{element_id}")
                                                        , scope: '#{scope}'
                                                        , projection: '#{projection}'
                                                        , fills: {#{js_fills.join(',')}}
                                                        , data: {
                                                                #{state_data.join(',')}
                                                        }
                                                        , done: function(datamap) {
                                                                #{events.join(',')}
                                                        }
                                                        , geographyConfig: {
                                                                popupTemplate: function(geo, data) {
                                                                        return ['<div class="hoverinfo">', #{geo_popupTemplate}, '</div>'].join('')
                                                                }
                                                                , hideAntarctica: #{geo_hideAntarctica}
                                                                , borderWidth: #{geo_borderWidth}
                                                                , borderColor: '#{geo_borderColor}'
                                                                , popupOnHover: #{geo_popoverOnHover}
                                                                , highlightOnHover: #{geo_highlightOnHover}
                                                                , highlightFillColor: '#{geo_highlightFillColor}'
                                                                , highlightBorderColor: '#{geo_highlightBorderColor}'
                                                                , highlightBorderWidth: #{geo_highlightBorderWidth}
                                                        }
                                                })

                                                var bubbles_#{element_id} = [#{js_bubbles.join(',')}]
                                                if (bubbles_#{element_id}.length > 0) {
                                                        map_#{element_id}.bubbles(bubbles_#{element_id}, {
                                                                popupTemplate: function (geo, data) { 
                                                                        return ['<div class="hoverinfo">', #{bubble_popup}, '</div>'].join('')
                                                                }
                                                                , borderWidth: #{bubble_borderWidth}
                                                                , borderColor: '#{bubble_borderColor}'
                                                                , popupOnHover: #{bubble_popupOnHover}
                                                                , fillOpacity: #{bubble_fillOpacity}
                                                                , highlightOnHover: #{bubble_highlightOnHover}
                                                                , highlightFillColor: '#{bubble_highlightFillColor}'
                                                                , highlightBorderColor: '#{bubble_highlightBorderColor}'
                                                                , highlightBorderWidth: #{bubble_highlightBorderWidth}
                                                                , highlightFillOpacity: #{bubble_highlightFillOpacity}
                                                        })
                                                }

                                                if (#{show_legend}){
                                                        map_#{element_id}.legend()
                                                }
                                        })
                                </script>
                        JS

                        if options[:content_for]
                                content_for(options[:content_for]) { js.respond_to?(:html_safe) ? js.html_safe : js }
                        else
                                html += js
                        end

                        html.respond_to?(:html_safe) ? html.html_safe : html
                end
mapkick_usa(data = {}, options = {}) click to toggle source
# File lib/mapkick/helper.rb, line 3
def mapkick_usa(data = {}, options = {})
        mapkick_map('usa', data, options)
end
mapkick_world(data = {}, options = {}) click to toggle source
# File lib/mapkick/helper.rb, line 7
def mapkick_world(data = {}, options = {})
        mapkick_map('world', data, options)
end