libgd-gis 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72c8b1d43f60ad8615302e22054c3d5e00be6bd746c757f00d980e781f760b0c
-  data.tar.gz: 74d09fb46fe02d7d53c75f4c2a9acb6bbab24383b51ef9bd9ec3ad8c89e0253f
+  metadata.gz: e54f40ea70b79fc866db311f7ac994ca267483f62de518b2f6f4f5989957f5e6
+  data.tar.gz: c8825bd11685f5a0254bd5fdaa5b654cee53dff608a990ac91bc4bacfcba4f31
 SHA512:
-  metadata.gz: e09c62bf8ee7218019a2e69676cc9b7461982568842bb8afac861f38f290d7fec658ee15269915ec5a3ad925de4d5ef4e6dcdce0415d7b97d438d91795d022a5
-  data.tar.gz: e7a1a6f47da4bbf9db7e18de9c3184e4af3498f636f51ba8b8ee9aa25b1c57c9532be24e71ee76e2201f5f7a240cddc62e33f16d886a1673062d845163831664
+  metadata.gz: 7bf12c61f036e85b93aa1b7617fb2aa63f9c0fb788f3ad53e1bf313259b5847658e3c1c1cf2682227fdc9d542cabf86489cb94d9a79c5cf15949519dfe08be69
+  data.tar.gz: bdc13c7e7aa1e99f4328c3ea69699b4e8f548ea5aeb975b317a81fe136d8dc94b1e64655987f51a0fcf4db0af030ffd8e5a125ae8cd3191a34c8814575cffa0e

data/lib/gd/gis/font_helper.rb

@@ -1,5 +1,30 @@
 module GD
   module GIS
+    # Provides helper methods for discovering and selecting font files
+    # available on the local system.
+    #
+    # This module is primarily used to supply font paths to text-rendering
+    # components (such as PointsLayer labels) in environments where font
+    # availability is system-dependent.
+    #
+    # Font discovery is performed by scanning a set of well-known directories
+    # for TrueType and OpenType font files. The results are cached for the
+    # lifetime of the process.
+    #
+    # Supported font formats:
+    # - TrueType (.ttf)
+    # - OpenType (.otf)
+    # - TrueType Collection (.ttc)
+    #
+    # @example Select a random system font
+    #   font_path = GD::GIS::FontHelper.random
+    #
+    # @example Find a font by name fragment
+    #   font_path = GD::GIS::FontHelper.find("Noto")
+    #
+    # @note
+    #   This helper does not validate glyph coverage (e.g. CJK support).
+    #   It only locates font files present on the system.
     module FontHelper
       PATHS = [
         "/usr/share/fonts",
@@ -9,6 +34,16 @@ module GD
 
       EXTENSIONS = %w[ttf otf ttc].freeze
 
+      # Returns the list of all font files discovered on the system.
+      #
+      # The search is performed once and cached. Subsequent calls return
+      # the cached result.
+      #
+      # Font files are discovered by recursively scanning the directories
+      # defined in {PATHS} for files matching the extensions in {EXTENSIONS}.
+      #
+      # @return [Array<String>]
+      #   An array of absolute file paths to font files.
       def self.all
         @all ||= PATHS.flat_map do |path|
           next [] unless Dir.exist?(path)
@@ -19,10 +54,34 @@ module GD
         end.compact.uniq
       end
 
+      # Returns a randomly selected font file from the system.
+      #
+      # This is primarily intended as a fallback mechanism when no explicit
+      # font is configured by the caller.
+      #
+      # @return [String]
+      #   Absolute path to a font file.
+      #
+      # @raise [RuntimeError]
+      #   If no font files are found on the system.
+      #
+      # @note
+      #   The selected font is not guaranteed to support any particular
+      #   character set.
       def self.random
         all.sample or raise "GD::GIS::FontHelper: no fonts found on system"
       end
 
+      # Finds a font file whose filename includes the given name fragment.
+      #
+      # The match is case-insensitive and performed against the basename
+      # of each discovered font file.
+      #
+      # @param name [String]
+      #   A substring to search for in font filenames (e.g. "Noto", "DejaVu").
+      #
+      # @return [String, nil]
+      #   The path to the first matching font file, or nil if no match is found.
       def self.find(name)
         all.find do |f|
           File.basename(f).downcase.include?(name.downcase)

data/lib/gd/gis/layer_points.rb

@@ -38,26 +38,34 @@ module GD
         label: nil,
         font: nil,
         size: 12,
-        color: [0, 0, 0]
+        color: [0, 0, 0],
+        font_color: nil,
+        count: 0
       )
         @data = data
         @lon = lon
         @lat = lat
+        @color = color
 
         if icon.is_a?(Array) || icon.nil?
           fill, stroke = icon || [GD::GIS::ColorHelpers.random_rgb, GD::GIS::ColorHelpers.random_rgb]
           @icon = build_default_marker(fill, stroke)
+        elsif icon == "numeric" || icon == "alphabetic"
+          @icon = icon
+          @font_color = font_color
         else
           @icon = GD::Image.open(icon)
+          @icon.alpha_blending = true
+          @icon.save_alpha = true
         end
 
         @label = label
         @font  = font
         @size  = size
-        @color = color
+        @r, @g, @b, @a = color
+        @a = 0 if @a.nil?
+        @count = count
 
-        @icon.alpha_blending = true
-        @icon.save_alpha = true
       end
 
       # Builds a default circular marker icon.
@@ -92,8 +100,22 @@ module GD
       #
       # @return [void]
       def render!(img, projector)
-        w = @icon.width
-        h = @icon.height
+
+        case @icon
+          when "numeric"
+              value = @count
+          when "alphabetic"
+              value = (@count + 96).chr
+          else
+            value = "*"
+        end
+
+        if @icon.is_a?(GD::Image)
+          w = @icon.width 
+          h = @icon.height
+        else
+          w = radius_from_text(img, value, font: @font, size: @size) * 2
+        end
 
         @data.each do |row|
           lon = @lon.call(row)
@@ -101,25 +123,89 @@ module GD
 
           x, y = projector.call(lon, lat)
 
-          # icono
-          img.copy(@icon, x - (w / 2), y - (h / 2), 0, 0, w, h)
-
-          # etiqueta opcional
           next unless @label && @font
 
           text = @label.call(row)
           next if text.nil? || text.strip.empty?
-
           font_h = @size * 1.1
 
+          if @icon == "numeric" || @icon == "alphabetic"
+
+            draw_symbol_circle!(
+                    img: img,
+                    x: x,
+                    y: y,
+                    symbol: value,
+                    radius: 12,
+                    bg_color: @color,
+                    font_color: @font_color,
+                    font: @font,
+                    font_size: @size
+                  )
+          else
+            img.copy(@icon, x - (w / 2), y - (h / 2), 0, 0, w, h)
+          end
+
           img.text(text,
-                   x: x + (w / 2) + 4,
-                   y: y + (font_h / 2),
-                   size: @size,
-                   color: @color,
-                   font: @font)
+                  x: x + (w / 2) + 4,
+                  y: y + (font_h / 2),
+                  size: @size,
+                  color: GD::Color.rgba(@r, @g, @b, @a),
+                  font: @font)
         end
       end
+
+      # Draws a filled circle (bullet) with a centered numeric label.
+      #
+      # - x, y: circle center in pixels
+      # - y for text() is BASELINE (not top). We compute baseline to center the text.
+      def draw_symbol_circle!(img:, x:, y:, symbol:, radius:, bg_color:, font_color:, font:, font_size:, angle: 0.0)
+        diameter = radius_from_text(img, symbol, font: font, size: font_size) * 2
+
+        # 1) Bullet background
+        img.filled_ellipse(x, y, diameter, diameter, bg_color)
+
+        # 2) Measure text in pixels (matches rendering)
+        text = symbol.to_s
+        w, h = img.text_bbox(text, font: font, size: font_size, angle: angle)
+
+        # 3) Compute centered position:
+        # text() uses baseline Y, so:
+        # top_y     = y - h/2
+        # baseline  = top_y + h = y + h/2
+        text_x = (x - (w / 2.0)).round
+        text_y = (y + (h / 2.0)).round
+
+        # 4) Draw number
+        img.text(
+          text,
+          x: text_x,
+          y: text_y,
+          font: font,
+          size: font_size,
+          color: font_color
+        )
+      end
+
+      # Calculates a circle radius that fully contains the rendered text.
+      #
+      # img      : GD::Image
+      # text     : String (number, letters, etc.)
+      # font     : path to .ttf
+      # size     : font size in points
+      # padding  : extra pixels around text (visual breathing room)
+      #
+      def radius_from_text(img, text, font:, size:, padding: 4)
+        w, h = img.text_bbox(
+          text.to_s,
+          font: font,
+          size: size
+        )
+
+        # Use the larger dimension to ensure the text fits
+        (([w, h].max / 2.0).ceil) + padding
+      end
+
     end
   end
 end

data/lib/gd/gis/map.rb

@@ -113,6 +113,7 @@ module GD
           primary:   [],
           secondary: [],
           street:    [],
+          track:     [],
           minor:     [],
           rail:      [],
           water:     [],
@@ -132,6 +133,7 @@ module GD
 
         @debug = false
         @used_labels = {}
+        @count = 1
       end
 
       # Returns all features belonging to a given semantic layer.
@@ -155,7 +157,37 @@ module GD
         end
       end
 
+      # Creates a single text label for a named linear feature (LineString or
+      # MultiLineString), avoiding duplicate labels for the same named entity.
+      #
+      # Many datasets (especially OSM) split a single logical entity
+      # (rivers, streets, railways, etc.) into multiple line features that
+      # all share the same name. This method ensures that:
+      #
+      # - Only one label is created per unique entity name
+      # - The label is placed on a representative segment of the geometry
+      # - The logic is independent of the feature's semantic layer (water, road, rail)
+      #
+      # Labels are rendered using a PointsLayer because libgd-gis does not
+      # support text rendering directly on line geometries.
+      #
+      # The label position is chosen as the midpoint of the line coordinates.
+      # This is a simple heuristic that provides a reasonable placement without
+      # requiring geometry merging or topological analysis.
+      #
+      # @param feature [GD::GIS::Feature]
+      #   A feature with a linear geometry and a "name" property.
+      #
+      # @return [void]
+      #   Adds a PointsLayer to @points_layers if a label is created.
+      #
+      # @note
+      #   This method must be called during feature loading (add_geojson),
+      #   before rendering. It intentionally does not depend on map style
+      #   configuration, which is applied later during rendering.
       def maybe_create_line_label(feature)
+        return true if @style.global[:label] == false || @style.global[:label].nil?
+
         geom = feature.geometry
         return unless LINE_GEOMS.include?(geom["type"])
 
@@ -171,17 +203,15 @@ module GD
 
         lon, lat = coords[coords.size / 2]
 
-	puts @style
-
         @points_layers << GD::GIS::PointsLayer.new(
           [feature],
           lon:   ->(_) { lon },
           lat:   ->(_) { lat },
-	        icon: nil,
+          icon: @style.global[:label][:icon],
           label: ->(_) { name },
-      	  font:  GD::GIS::FontHelper.random,
-      	  size:  10,
-      	  color: GD::Color.rgb(0, 0, 0)
+          font:  @style.global[:label][:font] || GD::GIS::FontHelper.random,
+          size:  @style.global[:label][:size] || (6..20).to_a.sample,
+          color: @style.global[:label][:color] || GD::GIS::ColorHelpers.random_rgba
         )
 
         @used_labels[key] = true
@@ -207,7 +237,7 @@ module GD
             kind =
               case (feature.properties["objeto"] || feature.properties["waterway"]).to_s.downcase
               when /river|río|canal/	then :river
-              when /stream|arroyo/ 	then :stream
+              when /stream|arroyo/	then :stream
               else :minor
               end
 
@@ -220,9 +250,7 @@ module GD
             @layers[:park] << feature
 
           when :track
-            # elegí una:
-            @layers[:minor] << feature
-            # o @layers[:street] << feature
+            @layers[:track] << feature
           else
             geom_type = feature.geometry["type"]
 
@@ -231,20 +259,20 @@ module GD
                 warn "Style error: missing 'points' section"
               end
 
-              font = points_style[:font] || begin
+              font = @style.points[:font] || begin
                 warn "[libgd-gis] points.font not defined in style, using random system font"
                 GD::GIS::FontHelper.random
               end
 
-              size = points_style[:size] || begin
+              size = @style.points[:size] || begin
                 warn "[libgd-gis] points.font size not defined in style, using random system font size"
                 (6..14).to_a.sample
               end
 
-              raw_color = points_style[:color]
-              color = @style.normalize_color(raw_color)
+              color = @style.points[:color] ? @style.normalize_color(@style.points[:color]) : GD::GIS::ColorHelpers.random_vivid
+              font_color = @style.points[:font_color] ? @style.normalize_color(@style.points[:font_color]) : [250, 250, 250, 0]
 
-              icon  = if points_style.key?(:icon_fill) && points_style.key?(:icon_stroke)
+              icon  = if @style.points.key?(:icon_fill) && @style.points.key?(:icon_stroke)
                         [points_style[:icon_stroke],
                          points_style[:icon_stroke]]
                       end
@@ -258,8 +286,11 @@ module GD
                 label: ->(f) { f.properties["name"] },
                 font:  font,
                 size:  size,
-                color: color
+                color: color,
+                font_color: font_color,
+                count: @count
               )
+              @count += 1
             elsif LINE_GEOMS.include?(geom_type)
               @layers[:minor] << feature
             end
@@ -272,8 +303,8 @@ module GD
       # @param data [Enumerable]
       # @param opts [Hash]
       # @return [void]
-      def add_points(data, **opts)
-        @points_layers << GD::GIS::PointsLayer.new(data, **opts)
+      def add_points(data, **)
+        @points_layers << GD::GIS::PointsLayer.new(data, **)
       end
 
       # Adds a generic lines overlay layer.
@@ -281,8 +312,8 @@ module GD
       # @param features [Array]
       # @param opts [Hash]
       # @return [void]
-      def add_lines(features, **opts)
-        @lines_layers << GD::GIS::LinesLayer.new(features, **opts)
+      def add_lines(features, **)
+        @lines_layers << GD::GIS::LinesLayer.new(features, **)
       end
 
       # Adds a generic polygons overlay layer.
@@ -290,8 +321,8 @@ module GD
       # @param polygons [Array]
       # @param opts [Hash]
       # @return [void]
-      def add_polygons(polygons, **opts)
-        @polygons_layers << GD::GIS::PolygonsLayer.new(polygons, **opts)
+      def add_polygons(polygons, **)
+        @polygons_layers << GD::GIS::PolygonsLayer.new(polygons, **)
       end
 
       # Renders the map.
@@ -438,6 +469,8 @@ module GD
           case kind
           when :street, :primary, :motorway, :secondary, :minor
             @style.roads[kind]
+          when :track
+            @style.track[kind]
           when :rail
             @style.rails
           when :water
@@ -475,7 +508,9 @@ module GD
             if POLY_GEOMS.include?(geom)
               f.draw(@image, projection, nil, nil, style)
             elsif style[:stroke]
-              color = GD::Color.rgb(*style[:stroke])
+              r, g, b, a = style[:stroke]
+              a = 0 if a.nil?
+              color = GD::Color.rgba(r, g, b, a)
 
               color = GD::GIS::ColorHelpers.random_vivid if @debug
 

data/lib/gd/gis/ontology.yml

@@ -32,5 +32,4 @@ track:
   gps:
     name:
       - track
-
-
+      - Track

data/lib/gd/gis/style.rb

@@ -14,6 +14,9 @@ module GD
     # to a {GD::GIS::Map} instance before rendering.
     #
     class Style
+      # @return [Hash] global styling rules
+      attr_reader :global
+
       # @return [Hash] road styling rules
       attr_reader :roads
 
@@ -29,6 +32,9 @@ module GD
       # @return [Hash] point styling rules
       attr_reader :points
 
+      # @return [Hash] track styling rules
+      attr_reader :track
+
       # @return [Array<Symbol>] drawing order of semantic layers
       attr_reader :order
 
@@ -36,13 +42,15 @@ module GD
       #
       # @param definition [Hash]
       #   style definition with optional sections:
-      #   :roads, :rails, :water, :parks, :points, :order
+      #   :global, :roads, :rails, :water, :parks, :points, :order, :track
       def initialize(definition)
+        @global = definition[:global] || {}
         @roads = definition[:roads] || {}
         @rails = definition[:rails] || {}
         @water = definition[:water] || {}
         @parks = definition[:parks] || {}
         @points = definition[:points] || {}
+        @track = definition[:track] || {}
         @order = definition[:order] || []
       end
 
@@ -70,8 +78,10 @@ module GD
         data = deep_symbolize(data)
 
         new(
+          global: data[:global],
           roads: data[:roads],
           rails: data[:rail] || data[:rails],
+          track: data[:track],
           water: data[:water],
           parks: data[:park] || data[:parks],
           points: data[:points],

data/lib/test.rb

@@ -0,0 +1,4 @@
+def foo
+end
+
+foo(1, 2)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: libgd-gis
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Germán Alberto Giménez Silva
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-libgd
@@ -30,34 +29,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.3
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.60'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.60'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.20'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.20'
 description: A native GIS raster engine for Ruby built on libgd. Render maps, GeoJSON,
   heatmaps and tiles.
 email:
@@ -86,11 +57,12 @@ files:
 - lib/gd/gis/projection.rb
 - lib/gd/gis/style.rb
 - lib/libgd_gis.rb
+- lib/test.rb
 homepage: https://github.com/ggerman/libgd-gis
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -105,8 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.4
 specification_version: 4
 summary: Geospatial raster rendering for Ruby using libgd
 test_files: []