ruby-gr 0.0.24 → 0.61.0.0

data/lib/gr.rb

@@ -48,23 +48,37 @@
 module GR
   class Error < StandardError; end
 
+  class NotFoundError < Error; end
+
   class << self
     attr_accessor :ffi_lib
   end
 
   require_relative 'gr_commons/gr_commons'
-  extend GRCommons::SearchSharedLibrary
 
   # Platforms |  path
   # Windows   |  bin/libgr.dll
-  # MacOSX    |  lib/libGR.so (NOT .dylib)
+  # MacOSX    |  lib/libGR.dylib ( <= v0.53.0 .so)
   # Ubuntu    |  lib/libGR.so
-  self.ffi_lib = case RbConfig::CONFIG['host_os']
-                 when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-                   search_shared_library('libgr.dll', 'gr')
-                 else
-                   search_shared_library('libGR.so', 'gr')
-                 end
+  platform = RbConfig::CONFIG['host_os']
+  lib_names, pkg_name = \
+    case platform
+    when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+      [['libGR.dll'], 'gr']
+    when /darwin|mac os/
+      ENV['GKSwstype'] ||= 'gksqt'
+      [['libGR.dylib', 'libGR.so'], 'gr']
+    else
+      [['libGR.so'], 'gr']
+    end
+
+  # On Windows + RubyInstaller,
+  # the environment variable GKS_FONTPATH will be set.
+  lib_path = GRCommons::GRLib.search(lib_names, pkg_name)
+
+  raise NotFoundError, "#{lib_names} not found" if lib_path.nil?
+
+  self.ffi_lib = lib_path
 
   require_relative 'gr/version'
   require_relative 'gr/ffi'
@@ -165,30 +179,78 @@ module GR
     # Draw a polyline using the current line attributes,
     # starting from the first data point and ending at the last data point.
     #
-    # @param x [Array, NArray] A list containing the X coordinates
-    # @param y [Array, NArray] A list containing the Y coordinates
+    # @param x         [Array, NArray]          A list containing the X coordinates
+    # @param y         [Array, NArray]          A list containing the Y coordinates
+    # @param linewidth [Array, NArray, Numeric] A list containing the line widths
+    # @param line_z    [Array, NArray, Numeric] A list to be converted to colors
     #
     # The values for x and y are in world coordinates.
     # The attributes that control the appearance of a polyline are linetype,
     # linewidth and color index.
     #
-    def polyline(x, y)
+    def polyline(x, y, linewidth = nil, line_z = nil)
+      # GR.jl - Multiple dispatch
       n = equal_length(x, y)
-      super(n, x, y)
+      if linewidth.nil? && line_z.nil?
+        super(n, x, y)
+      else
+        linewidth ||= GR.inqlinewidth
+        linewidth = if linewidth.is_a?(Numeric)
+                      Array.new(n, linewidth * 100)
+                    else
+                      raise ArgumentError if n != linewidth.length
+
+                      linewidth.map { |i| (100 * i).round }
+                    end
+        line_z ||= GR.inqcolor(989) # FIXME
+        color = if line_z.is_a?(Numeric)
+                  Array.new(n, line_z)
+                else
+                  raise ArgumentError if n != line_z.length
+
+                  to_rgb_color(line_z)
+                end
+        z = linewidth.to_a.zip(color).flatten # to_a : NArray
+        gdp(x, y, GDP_DRAW_LINES, z)
+      end
     end
 
     # Draw marker symbols centered at the given data points.
     #
-    # @param x [Array, NArray] A list containing the X coordinates
-    # @param y [Array, NArray] A list containing the Y coordinates
+    # @param x          [Array, NArray]          A list containing the X coordinates
+    # @param y          [Array, NArray]          A list containing the Y coordinates
+    # @param markersize [Array, NArray, Numeric] A list containing the marker sizes
+    # @param marker_z   [Array, NArray, Numeric] A list to be converted to colors
     #
     # The values for x and y are in world coordinates.
     # The attributes that control the appearance of a polymarker are marker type,
     # marker size scale factor and color index.
     #
-    def polymarker(x, y)
+    def polymarker(x, y, markersize = nil, marker_z = nil)
+      # GR.jl - Multiple dispatch
       n = equal_length(x, y)
-      super(n, x, y)
+      if markersize.nil? && marker_z.nil?
+        super(n, x, y)
+      else
+        markersize ||= GR.inqmarkersize
+        markersize = if markersize.is_a?(Numeric)
+                       Array.new(n, markersize * 100)
+                     else
+                       raise ArgumentError if n != markersize.length
+
+                       markersize.map { |i| (100 * i).round }
+                     end
+        marker_z ||= GR.inqcolor(989) # FIXME
+        color = if marker_z.is_a?(Numeric)
+                  Array.new(n, marker_z)
+                else
+                  raise ArgumentError if n != marker_z.length
+
+                  to_rgb_color(marker_z)
+                end
+        z = markersize.to_a.zip(color).flatten # to_a : NArray
+        gdp(x, y, GDP_DRAW_MARKERS, z)
+      end
     end
 
     # Draw a text at position `x`, `y` using the current text attributes.
@@ -259,7 +321,9 @@ module GR
     def nonuniformcellarray(x, y, dimx, dimy, color)
       raise ArgumentError unless x.length == dimx + 1 && y.length == dimy + 1
 
-      super(x, y, dimx, dimy, 1, 1, dimx, dimy, int(color))
+      nx = dimx == x.length ? -dimx : dimx
+      ny = dimy == y.length ? -dimy : dimy
+      super(x, y, nx, ny, 1, 1, dimx, dimy, int(color))
     end
 
     # Display a two dimensional color index array mapped to a disk using polar
@@ -270,9 +334,9 @@ module GR
     # raidus. The center point of the resulting disk is located at `xorg`, `yorg`
     # and the radius of the disk is `rmax`.
     #
-    # @param xorg    [Numeric]       X coordinate of the disk center in world
+    # @param x_org   [Numeric]       X coordinate of the disk center in world
     #                                coordinates
-    # @param yorg    [Numeric]       Y coordinate of the disk center in world
+    # @param y_org   [Numeric]       Y coordinate of the disk center in world
     #                                coordinates
     # @param phimin  [Numeric]       start angle of the disk sector in degrees
     # @param phimax  [Numeric]       end angle of the disk sector in degrees
@@ -280,7 +344,7 @@ module GR
     #                                coordinates
     # @param rmax    [Numeric]       outer radius of the punctured disk in world
     #                                coordinates
-    # @param dimiphi [Integer]       Phi (X) dimension of the color index array
+    # @param dimphi  [Integer]       Phi (X) dimension of the color index array
     # @param dimr    [Integer]       iR (Y) dimension of the color index array
     # @param color   [Array, NArray] Color index array
     #
@@ -308,6 +372,27 @@ module GR
       super(x_org, y_org, phimin, phimax, rmin, rmax, dimphi, dimr, 1, 1, dimphi, dimr, int(color))
     end
 
+    # Display a two dimensional color index array mapped to a disk using polar
+    # coordinates with nonuniform cell sizes.
+    #
+    # @param phi   [Array, NArray] array with the angles of the disk sector in degrees
+    # @param r     [Array, NArray] array with the radii of the disk in world coordinates
+    # @param ncol  [Integer] total number of columns in the color index array and the angle array
+    # @param nrow  [Integer] total number of rows in the color index array and the radii array
+    # @param color [Integer] color index array
+    #
+    # The mapping of the polar coordinates and the drawing is performed simialr
+    # to `gr_polarcellarray` with the difference that the individual cell sizes
+    # are specified allowing nonuniform sized cells.
+    #
+    def nonuniformpolarcellarray(phi, r, ncol, nrow, color)
+      raise ArgumentError unless (ncol..(ncol + 1)).include?(phi.length) && (nrow..(nrow + 1)).include?(r.length)
+
+      dimphi = ncol == phi.length ? -ncol : ncol
+      dimr = nrow == r.length ? -nrow : nrow
+      super(0, 0, phi, r, dimphi, dimr, 1, 1, ncol, nrow, int(color))
+    end
+
     # Generates a generalized drawing primitive (GDP) of the type you specify,
     # using specified points and any additional information contained in a data
     # record.
@@ -320,7 +405,7 @@ module GR
     def gdp(x, y, primid, datrec)
       n = equal_length(x, y)
       ldr = datrec.length
-      super(n, x, y, primid, ldr, datrec)
+      super(n, x, y, primid, ldr, int(datrec))
     end
 
     # Generate a cubic spline-fit,
@@ -777,7 +862,7 @@ module GR
 
     # Set the clipping indicator.
     #
-    # @params indicator [Integer] An indicator specifying whether clipping is on
+    # @param indicator [Integer] An indicator specifying whether clipping is on
     #                             or off.
     # * 0 : Clipping is off. Data outside of the window will be drawn.
     # * 1 : Clipping is on. Data outside of the window will not be drawn.
@@ -1296,7 +1381,7 @@ module GR
     # @param x      [Array, NArray] A list containing the X coordinates
     # @param y      [Array, NArray] A list containing the Y coordinates
     # @param z      [Array, NArray] A list containing the Z coordinates
-    # @param lavels [Array, NArray] A list of contour levels
+    # @param levels [Array, NArray] A list of contour levels
     #
     def tricontour(x, y, z, levels)
       npoints = x.length # equal_length ?
@@ -1355,6 +1440,16 @@ module GR
       super(n, r, g, b, positions)
     end
 
+    # Inquire the color index range of the current colormap.
+    #
+    # @return [Array] first_color_ind The color index of the first color,
+    #                 last_color_ind The color index of the last color
+    def inqcolormapinds
+      inquiry %i[int int] do |first_color_ind, last_color_ind|
+        super(first_color_ind, last_color_ind)
+      end
+    end
+
     # @!method colorbar
 
     def inqcolor(color)
@@ -1413,7 +1508,15 @@ module GR
     #  * .webm 	     : WebM video file
     #  * .ogg 	     : Ogg video file
     #
-    # @!method beginprint
+    # @note Ruby feature - you can use block to call endprint automatically.
+
+    def beginprint(file_path)
+      super(file_path)
+      if block_given?
+        yield
+        endprint
+      end
+    end
 
     # Open and activate a print device with the given layout attributes.
     #
@@ -1534,14 +1637,14 @@ module GR
     # curves.
     #
     # @param points [Array, NArray] (N, 2) array of (x, y) vertices
-    # @parm codes [Array, NArray] N-length array of path codes
+    # @param codes [Array, NArray] N-length array of path codes
     #  *  STOP      : end the entire path
     #  *  MOVETO    : move to the given vertex
     #  *  LINETO    : draw a line from the current position to the given vertex
     #  *  CURVE3    : draw a quadratic Bézier curve
     #  *  CURVE4    : draw a cubic Bézier curve
     #  *  CLOSEPOLY : draw a line segment to the start point of the current path
-    # @parm fill [Integer]
+    # @param fill [Integer]
     #   A flag indication whether resulting path is to be filled or not
     #
     def drawpath(points, codes, fill)
@@ -1601,7 +1704,7 @@ module GR
     def readimage(path)
       # Feel free to make a pull request if you catch a mistake
       # or you have an idea to improve it.
-      data = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T)
+      data = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T, Fiddle::RUBY_FREE)
       w, h = inquiry [:int, :int] do |width, height|
         # data is a pointer of a pointer
         super(path, width, height, data.ref)
@@ -1739,7 +1842,7 @@ module GR
       # Feel free to make a pull request if you catch a mistake
       # or you have an idea to improve it.
       npoints = equal_length(x, y)
-      triangles = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T)
+      triangles = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T, Fiddle::RUBY_FREE)
       dim = 3
       n_tri = inquiry_int do |ntri|
         super(npoints, x, y, ntri, triangles.ref)
@@ -1829,7 +1932,8 @@ module GR
     #  * 3 : INTERP2_CUBIC   - Cubic interpolation
     # @param extrapval [Numeric] The extrapolation value
     #
-    def interp2(x, y, z, xq, yq, method, extrapval) # flatten
+    # flatten
+    def interp2(x, y, z, xq, yq, method, extrapval)
       nx = x.length
       ny = y.length
       # nz = z.length
@@ -2003,6 +2107,18 @@ module GR
       super(n, x, y, codes)
     end
 
+    # @param z [Array, NArray]
+    # @return [Array, NArray]
+    def to_rgb_color(z)
+      zmin, zmax = z.minmax
+      return Array.new(z.length, 0) if zmax == zmin
+
+      z.map  do |i|
+        zi = (i - zmin) / (zmax - zmin).to_f
+        inqcolor(1000 + (zi * 255).round)
+      end
+    end
+
     # Define the border width of subsequent path output primitives.
     #
     # @param width [Numeric] The border width scale factor
@@ -2023,13 +2139,19 @@ module GR
       inquiry_int { |pt| super(pt) }
     end
 
+    # @!method selectclipxform
+
+    def inqclipxform
+      inquiry_int { |pt| super(pt) }
+    end
+
     # Set the projection type with this flag.
     #
     # @param flag [Integer] projection type
     #  The available options are:
-    #  * 0 : GR_PROJECTION_DEFAULT      - default
-    #  * 1 : GR_PROJECTION_ORTHOGRAPHIC - orthographic
-    #  * 2 : GR_PROJECTION_PERSPECTIVE  - perspective
+    #  * 0 : PROJECTION_DEFAULT      - default
+    #  * 1 : PROJECTION_ORTHOGRAPHIC - orthographic
+    #  * 2 : PROJECTION_PERSPECTIVE  - perspective
     #
     # @!method setprojectiontype
 
@@ -2179,6 +2301,90 @@ module GR
         super(encoding)
       end
     end
+
+    # Load a font file from a given filename.
+    #
+    # This function loads a font from a given absolute filename and assigns a
+    # font index to it. To use the loaded font call `gr_settextfontprec` using
+    # the resulting font index and precision 3.
+    #
+    # @param filename [String] The absolute filename of the font
+    #
+    def loadfont(str)
+      inquiry_int do |font|
+        super(str, font)
+      end
+    end
+
+    # Set the number of threads which can run parallel.
+    # The default value is the number of threads the cpu has.
+    #
+    # @param num [Integer] num number of threads
+    #
+    # @!method setthreadnumber
+
+    # Set the width and height of the resulting picture.
+    # These values are only used for gr_volume and gr_cpubasedvolume.
+    # The default values are 1000 for both.
+    #
+    # @param width  [Integer] width of the resulting image
+    # @param height [Integer] height of the resulting image
+    #
+    # @!method setpicturesizeforvolume
+
+    # Set the gr_volume border type with this flag.
+    # This inflicts how the volume is calculated. When the flag is set to
+    # GR_VOLUME_WITH_BORDER the border will be calculated the same as the points
+    # inside the volume.
+    #
+    # @param flag [Integer] calculation of the gr_volume border
+    #  The available options are:
+    #  * 0 : VOLUME_WITHOUT_BORDER - default value
+    #  * 1 : VOLUME_WITH_BORDER    - gr_volume with border
+    #
+    # @!method setvolumebordercalculation    # @!method setthreadnumber
+
+    # Set if gr_cpubasedvolume is calculated approximative or exact.
+    # To use the exact calculation set approximative_calculation to 0.
+    # The default value is the approximative version, which can be set with the
+    # number 1.
+    #
+    # @param approximative_calculation [Integer] exact or approximative calculation
+    #                                            of the volume
+    #
+    # @!method setapproximativecalculation
+
+    # Inquire the parameters which can be set for cpubasedvolume.
+    # The size of the resulting image, the way the volumeborder is calculated and
+    # the amount of threads which are used.
+    #
+    # @return [Array]
+    #  * border -                    flag which tells how the border is calculated
+    #  * max_threads -               number of threads
+    #  * picture_width -             width of the resulting image
+    #  * picture_height -            height of the resulting image
+    #  * approximative_calculation - exact or approximative calculation of gr_cpubasedvolume
+    #
+    def inqvolumeflags
+      inquiry([:int] * 5) do |*pts|
+        super(*pts)
+      end
+    end
+
+    # FIXME! (#61)
+    # @!method cpubasedvolume
+
+    def inqvpsize
+      inquiry %i[int int double] do |*pts|
+        super(*pts)
+      end
+    end
+
+    def polygonmesh3d(px, py, pz, connections, colors)
+      n_points = equal_length(px, py, pz)
+      n_connections = colors.length
+      super(n_points, px, py, pz, n_connections, int(connections), int(colors))
+    end
   end
 
   ASF_BUNDLED    = 0
@@ -2387,6 +2593,10 @@ module GR
   PATH_CURVE4    = 0x04
   PATH_CLOSEPOLY = 0x4f
 
+  GDP_DRAW_PATH = 1
+  GDP_DRAW_LINES = 2
+  GDP_DRAW_MARKERS = 3
+
   MPL_SUPPRESS_CLEAR  = 1
   MPL_POSTPONE_UPDATE = 2
 

data/lib/gr3/ffi.rb

@@ -15,7 +15,7 @@ module GR3
       raise LoadError, 'Could not find GR Framework'
     end
 
-    extend GRCommons::Extern
+    extend GRCommons::TryExtern
 
     # https://github.com/sciapp/gr/blob/master/lib/gr3/gr3.h
     # keep same order
@@ -91,6 +91,8 @@ module GR3
            'double offset_x, double offset_y, double offset_z)'
     try_extern 'int gr3_createsurfacemesh(int *mesh, int nx, int ny, ' \
            'float *px, float *py, float *pz, int option)'
+    try_extern 'int gr3_createsurface3dmesh(int *mesh, int ncols, int nrows, ' \
+           'float *px, float *py, float *pz);'
     try_extern 'void gr3_drawmesh_grlike(int mesh, int n, ' \
            'const float *positions, const float *directions, const float *ups, ' \
            'const float *colors, const float *scales)'
@@ -138,5 +140,9 @@ module GR3
     # try_extern 'void gr3_drawtrianglesurface(int n, const float *triangles)'
     try_extern 'void gr_volume(int nx, int ny, int nz, double *data, ' \
            'int algorithm, double *dmin_ptr, double *dmax_ptr)'
+    try_extern 'void gr3_setorthographicprojection' \
+           '(float left, float right, float bottom, float top, float znear, float zfar)'
+    try_extern 'void gr3_setsurfaceoption(int option)'
+    try_extern 'int gr3_getsurfaceoption(void)'
   end
 end

data/lib/gr3.rb

@@ -58,23 +58,37 @@
 module GR3
   class Error < StandardError; end
 
+  class NotFoundError < Error; end
+
   class << self
     attr_accessor :ffi_lib
   end
 
   require_relative 'gr_commons/gr_commons'
-  extend GRCommons::SearchSharedLibrary
 
   # Platforms |  path
   # Windows   |  bin/libGR3.dll
-  # MacOSX    |  lib/libGR3.so (NOT .dylib)
+  # MacOSX    |  lib/libGR3.dylib ( <= v0.53.0 .so)
   # Ubuntu    |  lib/libGR3.so
-  self.ffi_lib = case RbConfig::CONFIG['host_os']
-                 when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-                   search_shared_library('libGR3.dll', 'gr3')
-                 else
-                   search_shared_library('libGR3.so', 'gr3')
-                 end
+  platform = RbConfig::CONFIG['host_os']
+  lib_names, pkg_name = \
+    case platform
+    when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+      [['libGR3.dll'], 'gr3']
+    when /darwin|mac os/
+      ENV['GKSwstype'] ||= 'gksqt'
+      [['libGR3.dylib', 'libGR3.so'], 'gr3']
+    else
+      [['libGR3.so'], 'gr3']
+    end
+
+  # On Windows + RubyInstaller,
+  # the environment variable GKS_FONTPATH will be set.
+  lib_path = GRCommons::GRLib.search(lib_names, pkg_name)
+
+  raise NotFoundError, "#{lib_names} not found" if lib_path.nil?
+
+  self.ffi_lib = lib_path
 
   require_relative 'gr3/version'
   require_relative 'gr3/ffi'
@@ -813,6 +827,7 @@ module GR3
   IA_END_OF_LIST        = 0
   IA_FRAMEBUFFER_WIDTH  = 1
   IA_FRAMEBUFFER_HEIGHT = 2
+  IA_NUM_THREADS        = 3
 
   # Error
   ERROR_NONE                   =  0
@@ -843,6 +858,11 @@ module GR3
   DRAWABLE_OPENGL = 1
   DRAWABLE_GKS    = 2
 
+  # Projection
+  PROJECTION_PERSPECTIVE  = 0
+  PROJECTION_PARALLEL     = 1
+  PROJECTION_ORTHOGRAPHIC = 2
+
   # SurfaceOption
   SURFACE_DEFAULT     =  0
   SURFACE_NORMALS     =  1

data/lib/gr_commons/define_methods.rb

@@ -16,9 +16,9 @@ module GRCommons
           args.map! do |arg|
             case arg
             when Array
-              GRCommons::GRCommonUtils.public_send(default_type, arg)
+              GRCommonUtils.public_send(default_type, arg)
             when ->(x) { defined?(Numo::NArray) && x.is_a?(Numo::NArray) }
-              GRCommons::GRCommonUtils.public_send(default_type, arg)
+              GRCommonUtils.public_send(default_type, arg)
             else
               arg
             end

data/lib/gr_commons/fiddley.rb

@@ -188,7 +188,7 @@ module GRCommons
           @size = @ptr.size
         else
           @size = type2size(type) * num
-          @ptr = Fiddle::Pointer.malloc(@size)
+          @ptr = Fiddle::Pointer.malloc(@size, Fiddle::RUBY_FREE)
         end
       end
 

data/lib/gr_commons/gr_common_utils.rb

@@ -43,7 +43,7 @@ module GRCommons
       if narray?(data)
         Numo::Int32.cast(data).to_binary
       else
-        Fiddley::Utils.array2str(:int32, data.to_a.flatten) # TODO
+        Fiddley::Utils.array2str(:int32, data.to_a.flatten)
       end
     end
 
@@ -52,7 +52,7 @@ module GRCommons
       if narray?(data)
         Numo::UInt32.cast(data).to_binary
       else
-        Fiddley::Utils.array2str(:uint, data.to_a.flatten) # TODO
+        Fiddley::Utils.array2str(:uint32, data.to_a.flatten)
       end
     end
 

data/lib/gr_commons/gr_commons.rb

@@ -7,8 +7,8 @@ end
 # Change the default encoding to UTF-8.
 ENV['GKS_ENCODING'] ||= 'utf8'
 
-require_relative 'search_shared_library'
-require_relative 'extern'
+require_relative 'gr_lib'
+require_relative 'try_extern'
 require_relative 'define_methods'
 require_relative 'gr_common_utils'
 require_relative 'jupyter_support'

data/lib/gr_commons/gr_lib.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'pkg-config'
+
+module GRCommons
+  # This module helps GR, GR and GRM to search the shared library.
+  #
+  # The order of priority:
+  # 1. RubyInstaller ( for Windows only )
+  # 2. Environment variable GRDIR
+  # 3. pkg-config : https://github.com/ruby-gnome/pkg-config
+  # The following packages (should) support pkg-config.
+  # - Linux
+  #   - Red Data Tools https://github.com/red-data-tools/packages.red-data-tools.org
+  #     - libgr-dev
+  #     - libgr3-dev
+  #     - libgrm-dev
+  # - Mac
+  #   - Homebrew https://github.com/Homebrew/homebrew-core
+  #     - libgr
+  # - Windows
+  #   - MinGW https://github.com/msys2/MINGW-packages
+  #     - mingw-w64-gr
+  module GRLib
+    class << self
+      # Check if using RubyInstaller or not.
+      def ruby_installer?
+        Object.const_defined?(:RubyInstaller)
+      end
+
+      # Return the directory path from the GRDIR environment variable.
+      def get_grdir_from_env(lib_names)
+        return nil unless ENV['GRDIR']
+        return ENV['GRDIR'] if Dir.exist?(ENV['GRDIR'])
+
+        warn "#{lib_names} : Dir GRDIR=#{ENV['GRDIR']} not found." # return nil
+      end
+
+      # Search the shared library.
+      # @note This method does not detect the Operating System.
+      #
+      # @param lib_names [Array] The actual file name of the shared library.
+      # @param pkg_name [String] The package name to be used when searching with pkg-configg
+      def search(lib_names, pkg_name)
+        # FIXME: There may be a better way to do it...
+        def lib_names.map_find(&block)
+          lazy.map(&block).find { |path| path }
+        end
+
+        # ENV['GRDIR']
+        # Verify that the directory exists.
+        grdir = get_grdir_from_env(lib_names)
+
+        # Windows + RubyInstaller
+        if ruby_installer?
+          grdir ||= File.join(RubyInstaller::Runtime.msys2_installation.msys_path,
+                              RubyInstaller::Runtime.msys2_installation.mingwarch)
+        end
+
+        # Search grdir
+        if grdir
+          lib_path = lib_names.map_find do |lib_name|
+            recursive_search(lib_name, grdir)
+          end
+        end
+
+        # Search with pkg-config
+        lib_path ||= lib_names.map_find do |lib_name|
+          pkg_config_search(lib_name, pkg_name)
+        end
+
+        # Windows + RubyInstaller
+        if ruby_installer?
+          RubyInstaller::Runtime.add_dll_directory(File.dirname(lib_path))
+          # FIXME: Where should I write this code?
+          ENV['GKS_FONTPATH'] ||= grdir
+        end
+
+        lib_path
+      end
+
+      # Recursive file search in directories
+      # @param name [String] File to search for
+      # @param base_dir [String] Directory to search
+      # @return path [String, NilClass] Returns the first path found.
+      #                                 If not found, nil is returned.
+      def recursive_search(name, base_dir)
+        Dir.chdir(base_dir) do
+          paths = Dir["**/#{name}"].sort
+          warn "More than one file found: #{paths}" if paths.size > 1
+          path = paths.first
+          File.expand_path(path) if path
+        end
+      end
+
+      # Use pkg-config to search for shared libraries
+      def pkg_config_search(lib_name, pkg_name)
+        PKGConfig.variable(pkg_name, 'sopath')
+      rescue PackageConfig::NotFoundError => e
+        warn "#{e.message} Cannot find #{lib_name}. "
+      end
+    end
+  end
+end