gr-plot 0.0.1 → 0.0.2

data/lib/gr/plot.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require 'gr'
+require_relative 'plot/version'
 autoload :GR3, 'gr3'
 
 # FIXME: Plot should not depend on Numo::Narrray unless the GR3 module is required.
 # Note: The Plot class has a linspace function that is independent of Numo..
 require 'numo/narray'
+require_relative 'plot/histogram'
 
 module GR
   # This class offers a simple, matlab-style API built on top of the GR package.
@@ -31,19 +33,106 @@ module GR
     # https://github.com/SciRuby/rubyplot
 
     # Plot kinds conform to GR.jl
-    PLOT_KIND = %i[line step scatter stem hist contour contourf hexbin heatmap
-                   nonuniformheatmap wireframe surface plot3 scatter3 imshow
-                   isosurface polar polarhist polarheatmap nonuniformpolarheatmap
-                   trisurf tricont shade volume].freeze
+    PLOT_KIND = %i[
+      line
+      step
+      stairs
+      scatter
+      stem
+      bar
+      hist
+      contour
+      contourf
+      hexbin
+      heatmap
+      nonuniformheatmap
+      wireframe
+      surface
+      plot3
+      scatter3
+      imshow
+      isosurface
+      polar
+      polarhist
+      polarheatmap
+      nonuniformpolarheatmap
+      trisurf
+      tricont
+      shade
+      volume
+    ].freeze
 
     # Keyword options conform to GR.jl.
-    KW_ARGS = %i[accelerate algorithm alpha ax backgroundcolor barwidth baseline
-                 clabels clear clim color colormap crange figsize font grid
-                 horizontal isovalue kind label labels levels linewidth location
-                 nbins ratio rotation scale size spec subplot tilt title update
-                 xaxis xflip xform xlabel xlim xlog xrange xticks yaxis yflip
-                 ylabel ylim ylog zflip yrange yticks viewport vp where window
-                 zaxis zlabel zlim zlog zrange zticks].freeze
+    KW_ARGS = %i[
+      accelerate
+      algorithm
+      alpha
+      ax
+      backgroundcolor
+      barwidth
+      baseline
+      borderwidth
+      clabels
+      clines
+      clear
+      clim
+      color
+      colormap
+      crange
+      dpi
+      figsize
+      font
+      grid
+      horizontal
+      isovalue
+      keepaspect
+      kind
+      label
+      labels
+      levels
+      linewidth
+      location
+      markersize
+      nbins
+      panzoom
+      ratio
+      rotation
+      scale
+      size
+      spec
+      subplot
+      theta_direction
+      theta_zero_location
+      tilt
+      title
+      update
+      viewport
+      vp
+      where
+      window
+      xaxis
+      xflip
+      xform
+      xlabel
+      xlim
+      xlog
+      xrange
+      xticks
+      yaxis
+      yflip
+      ylabel
+      ylim
+      ylog
+      yrange
+      yticks
+      zaxis
+      zflip
+      zlabel
+      zlim
+      zlog
+      zrange
+      zticks
+    ].freeze
 
     FONTS = {
       times_roman: 101,
@@ -78,12 +167,37 @@ module GR
       zapfchancery_mediumitalic: 130,
       zapfdingbats: 131,
       cmuserif_math: 232, # original: cmuserif-math
-      dejavusans: 233
+      dejavusans: 233,
+      stix_two_math: 234
     }.freeze
 
+    THETA_ZERO_LOCATION = {
+      'E' => 0,
+      'N' => Math::PI / 2,
+      'W' => Math::PI,
+      'S' => 1.5 * Math::PI
+    }.freeze
+
+    COLORS = [
+      [0xffffff, 0x000000, 0xff0000, 0x00ff00, 0x0000ff, 0x00ffff, 0xffff00, 0xff00ff],
+      [0x282c34, 0xd7dae0, 0xcb4e42, 0x99c27c, 0x85a9fc, 0x5ab6c1, 0xd09a6a, 0xc57bdb],
+      [0xfdf6e3, 0x657b83, 0xdc322f, 0x859900, 0x268bd2, 0x2aa198, 0xb58900, 0xd33682],
+      [0x002b36, 0x839496, 0xdc322f, 0x859900, 0x268bd2, 0x2aa198, 0xb58900, 0xd33682]
+    ].freeze
+
+    DISTINCT_CMAP = [0, 1, 984, 987, 989, 983, 994, 988].freeze
+
     @last_plot = nil
+    @scheme = 0
+
     class << self
-      attr_accessor :last_plot
+      attr_accessor :last_plot, :scheme
+
+      def usecolorscheme(index)
+        raise 'Invalid color scheme' unless index >= 1 && index <= 4
+
+        @scheme = index
+      end
     end
 
     attr_accessor :args, :kvs, :scheme
@@ -106,7 +220,7 @@ module GR
       kvs[:clear]   = true         unless kvs.has_key? :clear
       kvs[:update]  = true         unless kvs.has_key? :update
 
-      @scheme     = 0
+      @scheme     = self.class.scheme
       @background = 0xffffff
       # @handle     = nil           # This variable will be used in gr_meta
 
@@ -115,32 +229,38 @@ module GR
 
     def set_viewport(kind, subplot)
       mwidth, mheight, width, height = GR.inqdspsize
-      dpi = width / mwidth * 0.0254
-      w, h = if kvs[:figsize]
-               [(0.0254 * width  * kvs[:figsize][0] / mwidth),
-                (0.0254 * height * kvs[:figsize][1] / mheight)]
-             elsif dpi > 200
-               kvs[:size].map { |i| i * dpi / 100 }
-             else
-               kvs[:size]
-             end
-
-      vp = subplot.clone
+      if kvs.has_key?(:figsize)
+        w, h = kvs[:figsize]
+        if w < 2 && h < 2
+          w = width * w / mwidth
+          h = height * h / mheight
+        end
+      else
+        dpi = kvs[:dpi]
+        dpi ||= (width / mwidth * 0.0254).round
+        if dpi > 200
+          w, h = kvs[:size].map { |i| i * dpi / 100.0 }
+        else
+          w, h = kvs[:size]
+        end
+      end
+
+      vp = subplot.clone.map(&:to_f)
 
       if w > h
-        ratio = h / w.to_f
+        ratio = w / h.to_f
         msize = mwidth * w / width
-        GR.setwsviewport(0, msize, 0, msize * ratio)
-        GR.setwswindow(0, 1, 0, ratio)
-        vp[2] *= ratio
-        vp[3] *= ratio
+        GR.setwsviewport(0, msize, 0, msize / ratio)
+        GR.setwswindow(0, 1, 0, 1 / ratio)
+        vp[2] /= ratio
+        vp[3] /= ratio
       else
-        ratio = w / h.to_f
+        ratio = h / w.to_f
         msize = mheight * h / height
-        GR.setwsviewport(0, msize * ratio, 0, msize)
-        GR.setwswindow(0, ratio, 0, 1)
-        vp[0] *= ratio
-        vp[1] *= ratio
+        GR.setwsviewport(0, msize / ratio, 0, msize)
+        GR.setwswindow(0, 1 / ratio, 0, 1)
+        vp[0] /= ratio
+        vp[1] /= ratio
       end
 
       if %i[wireframe surface plot3 scatter3 trisurf volume].include?(kind)
@@ -154,7 +274,7 @@ module GR
       end
 
       left_margin = kvs.has_key?(:ylabel) ? 0.05 : 0
-      right_margin = if %i[contour contourf hexbin heatmap nonuniformheatmap polarheatmap
+      right_margin = if %i[contour contourf tricont hexbin heatmap nonuniformheatmap polarheatmap
                            nonuniformpolarheatmap surface trisurf volume].include?(kind)
                        (vp2 - vp1) * 0.1
                      else
@@ -171,9 +291,24 @@ module GR
       if %i[line step scatter stem].include?(kind) && kvs[:labels]
         location = kvs[:location] || 1
         if [11, 12, 13].include?(location)
-          w, h = legend_size
-          viewport[1] -= w + 0.1
+          w_legend, _h_legend = legend_size
+          viewport[1] -= w_legend + 0.1
+        end
+      end
+
+      if %i[polar polarhist polarheatmap nonuniformpolarheatmap].include?(kind)
+        xmin, xmax, ymin, ymax = viewport
+        xcenter = 0.5 * (xmin + xmax)
+        ycenter = 0.5 * (ymin + ymax)
+        r = 0.45 * [xmax - xmin, ymax - ymin].min
+        if kvs.has_key?(:title)
+          r *= 0.975
+          ycenter -= 0.025 * r
         end
+        viewport[0] = xcenter - r
+        viewport[1] = xcenter + r
+        viewport[2] = ycenter - r
+        viewport[3] = ycenter + r
       end
 
       GR.setviewport(*viewport)
@@ -182,29 +317,21 @@ module GR
       kvs[:vp]       = vp
       kvs[:ratio]    = ratio
 
-      if kvs[:backgroundcolor]
-        GR.savestate
-        GR.selntran(0)
-        GR.setfillintstyle(GR::INTSTYLE_SOLID)
-        GR.setfillcolorind(kvs[:backgroundcolor])
-        if w > h
-          GR.fillrect(subplot[0], subplot[1],
-                      ratio * subplot[2], ratio * subplot[3])
-        else
-          GR.fillrect(ratio * subplot[0], ratio * subplot[1],
-                      subplot[2], subplot[3])
-        end
-        GR.selntran(1)
-        GR.restorestate
-      end
+      return unless kvs[:backgroundcolor]
 
-      if %i[polar polarhist polarheatmap nonuniformpolarheatmap].include? kind
-        xmin, xmax, ymin, ymax = viewport
-        xcenter = 0.5 * (xmin + xmax)
-        ycenter = 0.5 * (ymin + ymax)
-        r = 0.5 * [xmax - xmin, ymax - ymin].min
-        GR.setviewport(xcenter - r, xcenter + r, ycenter - r, ycenter + r)
+      GR.savestate
+      GR.selntran(0)
+      GR.setfillintstyle(GR::INTSTYLE_SOLID)
+      GR.setfillcolorind(kvs[:backgroundcolor])
+      if w > h
+        GR.fillrect(subplot[0], subplot[1],
+                    ratio * subplot[2], ratio * subplot[3])
+      else
+        GR.fillrect(ratio * subplot[0], ratio * subplot[1],
+                    subplot[2], subplot[3])
       end
+      GR.selntran(1)
+      GR.restorestate
     end
 
     def set_window(kind)
@@ -239,14 +366,13 @@ module GR
       kvs[:zticks] = [kvs[:zticks], major_count] if kvs[:zticks].is_a? Numeric
 
       xmin, xmax = kvs[:xrange]
-      if %i[heatmap polarheatmap].include?(kind) && kvs.has_key?(:xlim)
+      if kind == :heatmap && !kvs.has_key?(:xlim)
         xmin -= 0.5
         xmax += 0.5
       end
       xtick, majorx = if (scale & GR::OPTION_X_LOG) == 0
-                        if !%i[heatmap polarheatmap].include?(kind) &&
-                           !kvs.has_key?(:xlim) &&
-                           !kvs[:panzoom]
+                        if !kvs.has_key?(:xlim) && !kvs[:panzoom] &&
+                           !%i[heatmap polarheatmap nonuniformpolarheatmap].include?(kind)
                           xmin, xmax = GR.adjustlimits(xmin, xmax)
                         end
                         if kvs.has_key?(:xticks)
@@ -261,21 +387,16 @@ module GR
       kvs[:xaxis] = xtick, xorg, majorx
 
       ymin, ymax = kvs[:yrange]
-      if %i[heatmap polarheatmap].include?(kind) && kvs.has_key?(:ylim)
+      if kind == :heatmap && !kvs.has_key?(:ylim)
         ymin -= 0.5
         ymax += 0.5
       end
-      if kind == :hist
-        if kvs[:horizontal] && !kvs.has_key?(:xlim)
-          xmin = (scale & GR::OPTION_X_LOG) == 0 ? 0 : 1
-        elsif !kvs.has_key?(:ylim)
-          ymin = (scale & GR::OPTION_Y_LOG) == 0 ? 0 : 1
-        end
+      if kind == :hist && !kvs.has_key?(:ylim)
+        ymin = (scale & GR::OPTION_Y_LOG) == 0 ? 0 : 1
       end
       ytick, majory = if (scale & GR::OPTION_Y_LOG) == 0
-                        if !%i[heatmap polarheatmap].include?(kind) &&
-                           !kvs.has_key?(:ylim) &&
-                           !kvs[:panzoom]
+                        if !kvs.has_key?(:ylim) && !kvs[:panzoom] &&
+                           !%i[heatmap polarheatmap nonuniformpolarheatmap].include?(kind)
                           ymin, ymax = GR.adjustlimits(ymin, ymax)
                         end
                         if kvs.has_key?(:yticks)
@@ -292,7 +413,7 @@ module GR
       if %i[wireframe surface plot3 scatter3 trisurf volume].include?(kind)
         zmin, zmax = kvs[:zrange]
         ztick, majorz = if (scale & GR::OPTION_Z_LOG) == 0
-                          zmin, zmax = GR.adjustlimits(zmin, zmax) if kvs.has_key?(:zlim)
+                          zmin, zmax = GR.adjustlimits(zmin, zmax) unless kvs.has_key?(:zlim)
                           if kvs.has_key?(:zticks)
                             kvs[:zticks]
                           else
@@ -306,10 +427,12 @@ module GR
       end
 
       kvs[:window] = xmin, xmax, ymin, ymax
-      if %i[polar polarhist polarheatmap nonuniformpolarheatmap trisurf].include?(kind)
+      if %i[polar polarhist polarheatmap nonuniformpolarheatmap].include?(kind)
         GR.setwindow(-1, 1, -1, 1)
+        GR.setclipregion(GR::REGION_ELLIPSE)
       else
         GR.setwindow(xmin, xmax, ymin, ymax)
+        GR.setclipregion(GR::REGION_RECTANGLE)
       end
       if %i[wireframe surface plot3 scatter3 trisurf volume].include?(kind)
         rotation = kvs[:rotation] || 40
@@ -325,7 +448,6 @@ module GR
     def draw_axes(kind, pass = 1)
       viewport = kvs[:viewport]
       vp = kvs[:vp]
-      _ratio = kvs[:ratio]
       xtick, xorg, majorx = kvs[:xaxis]
       ytick, yorg, majory = kvs[:yaxis]
       drawgrid = kvs.has_key?(:grid) ? kvs[:grid] : true
@@ -339,27 +461,61 @@ module GR
         charheight = [0.024 * diag, 0.012].max
         GR.setcharheight(charheight)
         ztick, zorg, majorz = kvs[:zaxis]
+        rotation = kvs[:rotation] || 40
+        tilt = kvs[:tilt] || 60
+        zi = tilt >= 0 && tilt <= 90 ? 0 : 1 # Julia: 1-based index -> Ruby: 0-based index
+        xlabel = (kvs[:xlabel] || '').to_s
+        ylabel = (kvs[:ylabel] || '').to_s
+        zlabel = (kvs[:zlabel] || '').to_s
+        GR.setcharheight(charheight * 1.5)
+        GR.settitles3d(xlabel, ylabel, zlabel)
+        GR.setcharheight(charheight)
         if pass == 1 && drawgrid
-          GR.grid3d(xtick, 0, ztick, xorg[0], yorg[1], zorg[0], 2, 0, 2)
-          GR.grid3d(0, ytick, 0, xorg[0], yorg[1], zorg[0], 0, 2, 0)
+          if rotation >= 0 && rotation < 90
+            GR.grid3d(xtick, 0, ztick, xorg[0], yorg[1], zorg[zi], 2, 0, 2)
+            GR.grid3d(0, ytick, 0, xorg[0], yorg[1], zorg[zi], 0, 2, 0)
+          elsif rotation >= 90 && rotation < 180
+            GR.grid3d(xtick, 0, ztick, xorg[1], yorg[1], zorg[zi], 2, 0, 2)
+            GR.grid3d(0, ytick, 0, xorg[1], yorg[1], zorg[zi], 0, 2, 0)
+          elsif rotation >= 180 && rotation < 270
+            GR.grid3d(xtick, 0, ztick, xorg[1], yorg[0], zorg[zi], 2, 0, 2)
+            GR.grid3d(0, ytick, 0, xorg[1], yorg[0], zorg[zi], 0, 2, 0)
+          else
+            GR.grid3d(xtick, 0, ztick, xorg[0], yorg[0], zorg[0], 2, 0, 2)
+            GR.grid3d(0, ytick, 0, xorg[0], yorg[0], zorg[zi], 0, 2, 0)
+          end
+        elsif rotation >= 0 && rotation < 90
+          GR.axes3d(xtick, 0, ztick, xorg[0], yorg[0], zorg[zi], majorx, 0, majorz, -ticksize)
+          GR.axes3d(0, ytick, 0, xorg[1], yorg[0], zorg[zi], 0, majory, 0, ticksize)
+        elsif rotation >= 90 && rotation < 180
+          GR.axes3d(0, 0, ztick, xorg[0], yorg[1], zorg[zi], 0, 0, majorz, -ticksize)
+          GR.axes3d(xtick, ytick, 0, xorg[0], yorg[0], zorg[zi], majorx, majory, 0, -ticksize)
+        elsif rotation >= 180 && rotation < 270
+          GR.axes3d(xtick, 0, ztick, xorg[1], yorg[1], zorg[zi], majorx, 0, majorz, ticksize)
+          GR.axes3d(0, ytick, 0, xorg[0], yorg[0], zorg[zi], 0, majory, 0, -ticksize)
         else
-          GR.axes3d(xtick, 0, ztick, xorg[0], yorg[0], zorg[0], majorx, 0, majorz, -ticksize)
-          GR.axes3d(0, ytick, 0, xorg[1], yorg[0], zorg[0], 0, majory, 0, ticksize)
+          GR.axes3d(0, 0, ztick, xorg[1], yorg[0], zorg[zi], 0, 0, majorz, -ticksize)
+          GR.axes3d(xtick, ytick, 0, xorg[1], yorg[1], zorg[zi], majorx, majory, 0, ticksize)
         end
       else
         charheight = [0.018 * diag, 0.012].max
         GR.setcharheight(charheight)
-        if %i[heatmap nonuniformheatmap shade].include?(kind)
+        if %i[heatmap nonuniformheatmap shade contourf].include?(kind)
           ticksize = -ticksize
-        elsif drawgrid
-          GR.grid(xtick, ytick, 0, 0, majorx, majory)
+          drawgrid = false if kind == :shade
         end
         if kvs.has_key?(:xticklabels) || kvs.has_key?(:yticklabels)
+          GR.grid(xtick, ytick, 0, 0, majorx, majory) if drawgrid
           fx = if kvs.has_key?(:xticklabels)
                  GRCommons::Fiddley::Function.new(
                    :void, %i[double double string double]
                  ) do |x, y, _svalue, value|
-                   label = value < 0 ? '' : kvs[:xticklabels][value] || ''
+                   idx = value.round - 1
+                   label = if idx >= 0 && idx < kvs[:xticklabels].size
+                             kvs[:xticklabels][idx]
+                           else
+                             ''
+                           end
                    GR.textext(x, y, label)
                  end
                else
@@ -373,7 +529,12 @@ module GR
                  GRCommons::Fiddley::Function.new(
                    :void, %i[double double string double]
                  ) do |x, y, _svalue, value|
-                   label = value < 0 ? '' : kvs[:yticklabels][value] || ''
+                   idx = value.round - 1
+                   label = if idx >= 0 && idx < kvs[:yticklabels].size
+                             kvs[:yticklabels][idx]
+                           else
+                             ''
+                           end
                    GR.textext(x, y, label)
                  end
                else
@@ -385,9 +546,12 @@ module GR
                end
           GR.axeslbl(xtick, ytick, xorg[0], yorg[0], majorx, majory, ticksize, fx, fy)
         else
-          GR.axes(xtick, ytick, xorg[0], yorg[0], majorx, majory, ticksize)
+          x_axis = GR.axis('X', tick: xtick, org: xorg[0], major_count: majorx, tick_size: ticksize)
+          y_axis = GR.axis('Y', tick: ytick, org: yorg[0], major_count: majory, tick_size: ticksize)
+          options = GR::AXES_SIMPLE_AXES | GR::AXES_TWIN_AXES
+          options |= GR::AXES_WITH_GRID if drawgrid
+          GR.drawaxes(x_axis, y_axis, options)
         end
-        GR.axes(xtick, ytick, xorg[1], yorg[1], -majorx, -majory, -ticksize)
       end
 
       if kvs.has_key?(:title)
@@ -396,30 +560,26 @@ module GR
         text(0.5 * (viewport[0] + viewport[1]), vp[3], kvs[:title].to_s)
         GR.restorestate
       end
-      if %i[wireframe surface plot3 scatter3 trisurf volume].include?(kind)
-        xlabel = (kvs[:xlabel] || '').to_s
-        ylabel = (kvs[:ylabel] || '').to_s
-        zlabel = (kvs[:zlabel] || '').to_s
-        GR.titles3d(xlabel, ylabel, zlabel)
-      else
-        if kvs.has_key?(:xlabel)
-          GR.savestate
-          GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_BOTTOM)
-          text(0.5 * (viewport[0] + viewport[1]), vp[2] + 0.5 * charheight, kvs[:xlabel].to_s)
-          GR.restorestate
-        end
-        if kvs.has_key?(:ylabel)
-          GR.savestate
-          GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_TOP)
-          GR.setcharup(-1, 0)
-          text(vp[0] + 0.5 * charheight, 0.5 * (viewport[2] + viewport[3]), kvs[:ylabel].to_s)
-          GR.restorestate
-        end
+      return if %i[wireframe surface plot3 scatter3 trisurf volume].include?(kind)
+
+      if kvs.has_key?(:xlabel)
+        GR.savestate
+        GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_BOTTOM)
+        text(0.5 * (viewport[0] + viewport[1]), vp[2] + 0.5 * charheight, kvs[:xlabel].to_s)
+        GR.restorestate
       end
+      return unless kvs.has_key?(:ylabel)
+
+      GR.savestate
+      GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_TOP)
+      GR.setcharup(-1, 0)
+      text(vp[0] + 0.5 * charheight, 0.5 * (viewport[2] + viewport[3]), kvs[:ylabel].to_s)
+      GR.restorestate
     end
 
-    def draw_polar_axes
+    def draw_polar_axes(pass = 1)
       viewport = kvs[:viewport]
+      vp = kvs[:vp]
       diag = Math.sqrt((viewport[1] - viewport[0])**2 + (viewport[3] - viewport[2])**2)
       charheight = [0.018 * diag, 0.012].max
 
@@ -432,41 +592,82 @@ module GR
       GR.setlinetype(GR::LINETYPE_SOLID)
 
       tick = auto_tick(rmin, rmax)
-      n = ((rmax - rmin) / tick + 0.5).round
-      (n + 1).times do |i|
-        r = i.to_f / n
-        if i.even?
+      n = ((rmax - rmin) / tick).truncate
+      if n <= 4
+        tick /= 2.0
+        n *= 2
+      end
+
+      if pass == 1
+        GR.selntran(1)
+        (n + 1).times do |i|
+          r = i.to_f * tick / (rmax - rmin)
+          if r > 0 && r < 1
+            if i.even?
+              GR.setlinecolorind(88)
+              GR.drawarc(-r, r, -r, r, 0, 360)
+            else
+              GR.setlinecolorind(90)
+              GR.drawarc(-r, r, -r, r, 0, 360)
+            end
+          end
+        end
+        GR.setclip(0)
+        GR.setlinecolorind(88)
+        GR.drawarc(-1, 1, -1, 1, 0, 360)
+
+        GR.setclip(1)
+        sign = (kvs[:theta_direction] || 1) > 0 ? 1 : -1
+        offs = THETA_ZERO_LOCATION[kvs[:theta_zero_location] || 'E']
+        0.step(by: 45, to: 315) do |alpha|
+          sinf = Math.sin((alpha * sign) * Math::PI / 180 + offs)
+          cosf = Math.cos((alpha * sign) * Math::PI / 180 + offs)
           GR.setlinecolorind(88)
-          GR.drawarc(-r, r, -r, r, 0, 359) if i > 0
+          GR.polyline([cosf, 0], [sinf, 0])
+          GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_HALF)
+          x, y = GR.wctondc(1.1 * cosf, 1.1 * sinf)
+          GR.textext(x, y, "#{alpha}^o")
+        end
+
+        if kvs.has_key?(:title)
+          GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_TOP)
+          text(0.5 * (viewport[0] + viewport[1]), vp[3] - 0.02, kvs[:title].to_s)
+        end
+      end
+
+      if pass == 2
+        start = (rmin / tick).floor.truncate
+        (n + 1).times do |i|
+          j = start + i
+          next unless j * tick >= rmin
+
+          r = i.to_f * tick / (rmax - rmin)
+          next unless i.even?
+
           GR.settextalign(GR::TEXT_HALIGN_LEFT, GR::TEXT_VALIGN_HALF)
           x, y = GR.wctondc(0.05, r)
-          GR.text(x, y, (rmin + i * tick).to_s) # FIXME: round. significant digits.
-        else
-          GR.setlinecolorind(90)
-          GR.drawarc(-r, r, -r, r, 0, 359)
+          fmt = GR.getformat(start, rmin, rmax, tick, 2)
+          s = GR.ftoa(j * tick, fmt)
+          GR.text(x, y, s)
         end
       end
-      0.step(by: 45, to: 315) do |alpha|
-        sinf = Math.sin(alpha * Math::PI / 180)
-        cosf = Math.cos(alpha * Math::PI / 180)
-        GR.polyline([cosf, 0], [sinf, 0])
-        GR.settextalign(GR::TEXT_HALIGN_CENTER, GR::TEXT_VALIGN_HALF)
-        x, y = GR.wctondc(1.1 * cosf, 1.1 * sinf)
-        GR.textext(x, y, "#{alpha}^o")
-      end
+
       GR.restorestate
     end
 
     def plot_polar(θ, ρ)
       window = kvs[:window]
-      rmax = window[3].to_f
-      ρ = ρ.map { |i| i / rmax }
+      rmin = window[2]
+      rmax = window[3]
+      sign = (kvs[:theta_direction] || 1) > 0 ? 1 : -1
+      offs = THETA_ZERO_LOCATION[kvs[:theta_zero_location] || 'E']
+      ρ = ρ.map { |i| (i - rmin) / (rmax - rmin) }
       n = ρ.length
       x = []
       y = []
       n.times do |i|
-        x << ρ[i] * Math.cos(θ[i])
-        y << ρ[i] * Math.sin(θ[i])
+        x << ρ[i] * Math.cos(θ[i] * sign + offs)
+        y << ρ[i] * Math.sin(θ[i] * sign + offs)
       end
       GR.polyline(x, y)
     end
@@ -479,10 +680,21 @@ module GR
       if img.is_a? String
         width, height, data = GR.readimage(img)
       else
-        height, width = img.shape
+        if narray?(img)
+          height, width = img.shape
+          data = img
+        else
+          height = img.length
+          width = img[0].length
+          data = img.flatten
+        end
         cmin, cmax = kvs[:crange]
-        data = img.map { |i| normalize_color(i, cmin, cmax) }
-        data = data.map { |i| (1000 + i * 255).round }
+        if narray?(data)
+          data = (data - cmin) / (cmax - cmin)
+          data = (data * 255 + 1000).round.cast_to(Numo::Int32)
+        else
+          data = data.map { |i| (1000 + normalize_color(i, cmin, cmax) * 255).round }
+        end
       end
 
       if width * (viewport[3] - viewport[2]) < height * (viewport[1] - viewport[0])
@@ -501,12 +713,12 @@ module GR
 
       GR.selntran(0)
       GR.setscale(0)
-      if kvs.has_key?(:xflip)
+      if kvs[:xflip]
         tmp = xmax
         xmax = xmin
         xmin = tmp
       end
-      if kvs.has_key?(:yflip)
+      if kvs[:yflip]
         tmp = ymax
         ymax = ymin
         ymin = tmp
@@ -552,8 +764,9 @@ module GR
       nx, ny, nz = v.shape
       isovalue = ((kvs[:isovalue] || 0.5) - v.min) / (v.max - v.min)
       rotation = ((kvs[:rotation] || 40) * Math::PI / 180.0)
-      tilt = ((kvs[:tilt] || 70) * Math::PI / 180.0)
+      tilt = ((kvs[:tilt] || 60) * Math::PI / 180.0)
       r = 2.5
+      require 'gr3'
       GR3.clear
       mesh = GR3.createisosurfacemesh(values, [2.0 / (nx - 1), 2.0 / (ny - 1), 2.0 / (nz - 1)],
                                       [-1, -1, -1],
@@ -582,11 +795,12 @@ module GR
                   GR.inqscale
                 end
       GR.setscale(options & mask)
-      h = 0.5 * (zmax - zmin) / (colors - 1)
+      h = 0 # 0.5 * (zmax - zmin) / (colors - 1)
       GR.setwindow(0, 1, zmin, zmax)
+      GR.setclipregion(GR::REGION_RECTANGLE)
       GR.setviewport(viewport[1] + 0.02 + off, viewport[1] + 0.05 + off,
                      viewport[2], viewport[3])
-      l = linspace(1000, 1255, colors).map(&:round)
+      l = linspace(0, 1, colors).map { |i| (1000 + i * 255).round }
       GR.cellarray(0, 1, zmax + h, zmin - h, 1, colors, l)
       GR.setlinecolorind(1)
       diag = Math.sqrt((viewport[1] - viewport[0])**2 + (viewport[3] - viewport[2])**2)
@@ -594,14 +808,24 @@ module GR
       GR.setcharheight(charheight)
       if kvs[:scale] & GR::OPTION_Z_LOG == 0
         ztick = auto_tick(zmin, zmax)
-        GR.axes(0, ztick, 1, zmin, 0, 1, 0.005)
+        y_axis = GR.axis('Y', position: 1, tick: ztick, org: zmin, major_count: 1, tick_size: 0.005)
+        GR.drawaxis('Y', y_axis)
       else
         GR.setscale(GR::OPTION_Y_LOG)
-        GR.axes(0, 2, 1, zmin, 0, 1, 0.005)
+        y_axis = GR.axis('Y', position: 1, tick: 2, org: zmin, major_count: 1, tick_size: 0.005)
+        GR.drawaxis('Y', y_axis)
       end
       GR.restorestate
     end
 
+    def rgb(color)
+      [
+        ((color >> 16) & 0xff) / 255.0,
+        ((color >> 8) & 0xff) / 255.0,
+        (color & 0xff) / 255.0
+      ]
+    end
+
     def plot_data(_figure = true)
       # GR.init
 
@@ -619,7 +843,23 @@ module GR
       GR.clearws if kvs[:clear]
 
       if scheme != 0
-        # Not yet.
+        8.times do |colorind|
+          color = COLORS[scheme - 1][colorind]
+          r, g, b = rgb(color)
+          GR.setcolorrep(colorind, r, g, b)
+          GR.setcolorrep(DISTINCT_CMAP[colorind], r, g, b) if scheme != 1
+        end
+
+        r, g, b = rgb(COLORS[scheme - 1][0])
+        r2, g2, b2 = rgb(COLORS[scheme - 1][1])
+        rdiff = r2 - r
+        gdiff = g2 - g
+        bdiff = b2 - b
+
+        12.times do |colorind|
+          f = colorind / 11.0
+          GR.setcolorrep(91 - colorind, r + f * rdiff, g + f * gdiff, b + f * bdiff)
+        end
       end
 
       if kvs.has_key?(:font)
@@ -670,14 +910,26 @@ module GR
 
         when :line
           mask = GR.uselinespec(spec)
-          linewidth = kvs[:linewidth]
-          # Slightly different from Julia,
-          # Because the implementation of polyline and polymarker is different.
-          z ||= linewidth # FIXME
-          GR.polyline(x, y, z, c) if hasline(mask)
-          GR.polymarker(x, y, z, c) if hasmarker(mask)
-
-        when :step
+          if c
+            linewidth = kvs[:linewidth] || 1
+            z = Array.new(x.length, linewidth)
+            GR.polyline(x, y, z, c)
+          else
+            if hasline(mask)
+              linewidth = kvs[:linewidth] || 1
+              GR.setlinewidth(linewidth)
+              GR.polyline(x, y)
+            end
+            if hasmarker(mask)
+              markersize = kvs[:markersize] || 1
+              GR.setmarkersize(markersize)
+              borderwidth = kvs[:borderwidth] || 1
+              GR.setborderwidth(borderwidth)
+              GR.polymarker(x, y)
+            end
+          end
+
+        when :step, :stairs
           mask = GR.uselinespec(spec)
           if hasline(mask)
             where = kvs[:where] || 'mid'
@@ -711,43 +963,48 @@ module GR
 
         when :scatter
           GR.setmarkertype(GR::MARKERTYPE_SOLID_CIRCLE)
-          z = z&.map { |i| i * 0.01 }
-          c = c&.map { |i| normalize_color(i, *kvs[:crange]) }
-          GR.polymarker(x, y, z, c)
+          if z || c
+            if c
+              cmin, cmax = kvs[:crange]
+              c = c.map { |i| normalize_color(i, cmin, cmax) }
+              c = c.map { |i| (1000 + i * 255).round }
+            end
+            GR.polymarker(x, y, z, c)
+          else
+            GR.polymarker(x, y)
+          end
 
         when :stem
-          GR.setlinecolorind(1)
-          GR.polyline(kvs[:window][0..1], [0, 0])
           GR.setmarkertype(GR::MARKERTYPE_SOLID_CIRCLE)
           GR.uselinespec(spec)
           x = x.to_a if narray?(x)
           y = y.to_a if narray?(y)
           x.zip(y).each do |xi, yi|
             GR.polyline([xi, xi], [0, yi])
+            GR.polymarker([xi], [yi])
+          end
+          GR.setlinecolorind(1)
+          GR.polyline(kvs[:window][0..1], [0, 0])
+
+        when :bar
+          (0...x.length).step(2) do |i|
+            GR.setfillcolorind(989)
+            GR.setfillintstyle(GR::INTSTYLE_SOLID)
+            GR.fillrect(x[i], x[i + 1], y[i], y[i + 1])
+            GR.setfillcolorind(1)
+            GR.setfillintstyle(GR::INTSTYLE_HOLLOW)
+            GR.fillrect(x[i], x[i + 1], y[i], y[i + 1])
           end
-          GR.polymarker(x, y)
 
         when :hist
-          if kvs[:horizontal]
-            xmin = kvs[:window][0]
-            x.length.times do |i|
-              GR.setfillcolorind(989)
-              GR.setfillintstyle(GR::INTSTYLE_SOLID)
-              GR.fillrect(xmin, x[i], y[i], y[i + 1])
-              GR.setfillcolorind(1)
-              GR.setfillintstyle(GR::INTSTYLE_HOLLOW)
-              GR.fillrect(xmin, x[i], y[i], y[i + 1])
-            end
-          else
-            ymin = kvs[:window][2]
-            y.length.times do |i|
-              GR.setfillcolorind(989)
-              GR.setfillintstyle(GR::INTSTYLE_SOLID)
-              GR.fillrect(x[i], x[i + 1], ymin, y[i])
-              GR.setfillcolorind(1)
-              GR.setfillintstyle(GR::INTSTYLE_HOLLOW)
-              GR.fillrect(x[i], x[i + 1], ymin, y[i])
-            end
+          ymin = kvs[:window][2]
+          y.length.times do |i|
+            GR.setfillcolorind(989)
+            GR.setfillintstyle(GR::INTSTYLE_SOLID)
+            GR.fillrect(x[i], x[i + 1], ymin, y[i])
+            GR.setfillcolorind(1)
+            GR.setfillintstyle(GR::INTSTYLE_HOLLOW)
+            GR.fillrect(x[i], x[i + 1], ymin, y[i])
           end
 
         when :polarhist
@@ -762,6 +1019,7 @@ module GR
             GR.setfillintstyle(GR::INTSTYLE_HOLLOW)
             GR.fillarc(-ρ[i], ρ[i], -ρ[i], ρ[i], θ[i - 1], θ[i])
           end
+          draw_polar_axes(2)
 
         when :polarheatmap, :nonuniformpolarheatmap
           w, h = z.shape
@@ -781,9 +1039,10 @@ module GR
             θ = x.map { |i| i * 180 / Math::PI }
             GR.nonuniformpolarcellarray(θ, ρ, w, h, colors)
           end
-          draw_polar_axes
+          draw_polar_axes(1)
+          draw_polar_axes(2)
           kvs[:zrange] = [cmin, cmax]
-          colorbar
+          colorbar(0.025)
 
         when :contour, :contourf
           zmin, zmax = kvs[:zrange]
@@ -816,7 +1075,12 @@ module GR
           when :contour
             GR._contour_(x, y, h, z, clabels ? 1 : 1000)
           when :contourf
-            GR._contourf_(x, y, h, z, clabels ? 1 : 0)
+            clines = kvs.has_key?(:clines) ? kvs[:clines] : true
+            GR._contourf_(x, y, h, z, if clines
+                                        clabels ? 1 : 0
+                                      else
+                                        -1
+                                      end)
           end
           colorbar(0, h.length)
 
@@ -831,12 +1095,11 @@ module GR
         when :heatmap, :nonuniformheatmap
           case z
           when Array
-            if z.all? { |zi| zi.size = z[0].size }
-              w = z.size
-              h = z[0].size
-            else
-              raise
-            end
+            raise unless z.all? { |zi| zi.size == z[0].size }
+
+            w = z.size
+            h = z[0].size
+
           when ->(obj) { narray?(obj) }
             w, h = z.shape
           else
@@ -846,11 +1109,11 @@ module GR
           cmin, cmax = kvs[:crange]
           levels = kvs[:levels] || 256
           data = z.flatten.to_a.map { |i| normalize_color(i, cmin, cmax) } # NArray -> Array
-          if kind == :heatmap
+          if kind == :heatmap && !ENV['GR_SCALE_FACTOR']
             rgba = data.map { |v| to_rgba(v, cmap) }
             GR.drawimage(0.5, w + 0.5, h + 0.5, 0.5, w, h, rgba)
           else
-            colors = data.map { |i| (1000 + i * 255).round }
+            colors = data.map { |i| (i.nan? ? 1256 : 1000 + i * 255).round }
             GR.nonuniformcellarray(x, y, w, h, colors)
           end
           colorbar(0, levels)
@@ -887,9 +1150,14 @@ module GR
 
         when :volume
           algorithm = kvs[:algorithm] || 0
+          w, h, ratio = GR.inqvpsize
+          GR.setpicturesizeforvolume((w * ratio).round, (h * ratio).round)
           require 'gr3'
           GR3.clear
+          ambient, diffuse, specular, specular_power = GR3.getlightparameters
+          GR3.setlightparameters(0.8, 0.2, 0.1, 10.0)
           dmin, dmax = GR3.volume(z, algorithm)
+          GR3.setlightparameters(ambient, diffuse, specular, specular_power)
           draw_axes(kind, 2)
           kvs[:zrange] = [dmin, dmax]
           colorbar(0.05)
@@ -924,6 +1192,7 @@ module GR
         when :polar
           GR.uselinespec(spec)
           plot_polar(x, y)
+          draw_polar_axes(2)
 
         when :trisurf
           GR.trisurface(x, y, z)
@@ -934,25 +1203,15 @@ module GR
           zmin, zmax = kvs[:zrange]
           levels = linspace(zmin, zmax, 20)
           GR.tricontour(x, y, z, levels)
+          colorbar
 
         when :shade
           xform = kvs[:xform] || 5
-          if x.to_a.include? Float::NAN # FIXME: Ruby is different from Julia?
-            # How to check NArray?
+          if (x.respond_to?(:isnan) && x.isnan.any?) || (x.is_a?(Array) && x.include?(Float::NAN))
             GR.shadelines(x, y, xform: xform)
           else
             GR.shadepoints(x, y, xform: xform)
           end
-
-        when :bar
-          0.step(x.length - 1, 2) do |i|
-            GR.setfillcolorind(989)
-            GR.setfillintstyle(GR::INTSTYLE_SOLID)
-            GR.fillrect(x[i], x[i + 1], y[i], y[i + 1])
-            GR.setfillcolorind(1)
-            GR.setfillintstyle(GR::INTSTYLE_HOLLOW)
-            GR.fillrect(x[i], x[i + 1], y[i], y[i + 1])
-          end
         end
 
         GR.restorestate
@@ -960,13 +1219,13 @@ module GR
 
       draw_legend if %i[line step scatter stem].include?(kind) && kvs.has_key?(:labels)
 
-      if kvs[:update]
-        GR.updatews
-        # if GR.isinline()
-        #  restore_context()
-        #  return GR.show()
-        # end
-      end
+      return unless kvs[:update]
+
+      GR.updatews
+      # if GR.isinline()
+      #  restore_context()
+      #  return GR.show()
+      # end
 
       # flag && restore_context()
     end
@@ -1077,6 +1336,8 @@ module GR
 
     # https://gist.github.com/rysk-t/8d1aef0fb67abde1d259#gistcomment-1925021
     def linspace(low, high, num)
+      return [low] if num == 1
+
       [*0..(num - 1)].collect { |i| low + i.to_f * (high - low) / (num - 1) }
     end
 
@@ -1086,6 +1347,7 @@ module GR
                              i.is_a?(Array) && (i[0].is_a?(Array) || narray?(i[0]))
                            end
       args.map do |xyzc|
+        xyzc = xyzc.dup
         spec = nil
         case xyzc.last
         when String
@@ -1094,20 +1356,28 @@ module GR
           spec = xyzc.pop[:spec]
         end
 
-        x, y, z, c = xyzc.map do |i|
-          if i.is_a?(Array) || narray?(i) || i.nil?
-            i
-          elsif i.respond_to?(:to_a)
-            # Convert an Array-like class such as Daru::Vector to an Array
-            i.to_a
-          else # String
-            i
-          end
+        x, y, z, c = xyzc.map { |i| plot_arg(i) }
+        if xyzc.size == 1 && y.nil?
+          y = x
+          x = linspace(1, y.length, y.length)
+        elsif y.respond_to?(:call)
+          y = x.map { |i| y.call(i) }
         end
         [x, y, z, c, spec]
       end
     end
 
+    def plot_arg(arg)
+      if arg.is_a?(Array) || narray?(arg) || arg.nil? || arg.respond_to?(:call)
+        arg
+      elsif arg.respond_to?(:to_a)
+        # Convert an Array-like class such as Daru::Vector to an Array
+        arg.to_a
+      else
+        arg
+      end
+    end
+
     # Normalize a color c with the range [cmin, cmax]
     #   0 <= normalize_color(c, cmin, cmax) <= 1
     def normalize_color(c, cmin, cmax)
@@ -1148,6 +1418,18 @@ module GR
       [a, b]
     end
 
+    def extrema(a)
+      amin = Float::INFINITY
+      amax = -Float::INFINITY
+      a.each do |el|
+        next if el.nil? || (el.is_a?(Float) && el.nan?)
+
+        amin = el if el < amin
+        amax = el if el > amax
+      end
+      [amin, amax]
+    end
+
     def minmax(kind)
       xmin = ymin = zmin = cmin = Float::INFINITY
       xmax = ymax = zmax = cmax = -Float::INFINITY
@@ -1158,10 +1440,10 @@ module GR
             # duck typing for NArray
             x = x.map { |v| v > 0 ? v : Float::NAN }
           end
-          x0, x1 = x.minmax
+          x0, x1 = extrema(x)
           xmin = [x0, xmin].min
           xmax = [x1, xmax].max
-        elsif kind == :volume
+        elsif %i[volume isosurface].include?(kind)
           xmin = -1
           xmax = 1
         else
@@ -1172,10 +1454,10 @@ module GR
           if scale & GR::OPTION_Y_LOG != 0
             y = y.map { |v| v > 0 ? v : Float::NAN }
           end
-          y0, y1 = y.minmax
+          y0, y1 = extrema(y)
           ymin = [y0, ymin].min
           ymax = [y1, ymax].max
-        elsif kind == :volume
+        elsif %i[volume isosurface].include?(kind)
           ymin = -1
           ymax = 1
         else
@@ -1186,18 +1468,24 @@ module GR
           if scale & GR::OPTION_Z_LOG != 0
             z = z.map { |v| v > 0 ? v : Float::NAN }
           end
-          z0, z1 = z.minmax
+          z0, z1 = extrema(z)
           zmin = [z0, zmin].min
           zmax = [z1, zmax].max
+        elsif %i[volume isosurface].include?(kind)
+          zmin = -1
+          zmax = 1
+        else
+          zmin = 0
+          zmax = 1
         end
         if c
-          c0, c1 = c.minmax
+          c0, c1 = extrema(c)
           cmin = [c0, cmin].min
           cmax = [c1, cmax].max
         elsif z
-          z0, z1 = z.minmax
-          cmin = [z0, zmin].min
-          cmax = [z1, zmax].max
+          c0, c1 = extrema(z)
+          cmin = [c0, cmin].min
+          cmax = [c1, cmax].max
         end
       end
       xmin, xmax = fix_minmax(xmin, xmax)
@@ -1205,9 +1493,9 @@ module GR
       zmin, zmax = fix_minmax(zmin, zmax)
 
       # kvs[:xlim], kvs[:ylim], kvs[:zlim] is supposed to be Array or Range
-      kvs[:xrange] = [(kvs[:xlim]&.first || xmin), (kvs[:xlim]&.last || xmax)]
-      kvs[:yrange] = [(kvs[:ylim]&.first || ymin), (kvs[:ylim]&.last || ymax)]
-      kvs[:zrange] = [(kvs[:zlim]&.first || zmin), (kvs[:zlim]&.last || zmax)]
+      kvs[:xrange] = [kvs[:xlim]&.first || xmin, kvs[:xlim]&.last || xmax]
+      kvs[:yrange] = [kvs[:ylim]&.first || ymin, kvs[:ylim]&.last || ymax]
+      kvs[:zrange] = [kvs[:zlim]&.first || zmin, kvs[:zlim]&.last || zmax]
 
       if kvs.has_key?(:clim)
         c0, c1 = kvs[:clim]
@@ -1228,10 +1516,15 @@ module GR
     def auto_tick(amin, amax)
       scale = 10.0**Math.log10(amax - amin).truncate
       tick_size = [5.0, 2.0, 1.0, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01]
-      i = tick_size.find_index do |tsize|
-        ((amax - amin) / scale / tsize) > 7 # maximum number of tick marks
+      tick = 1.0
+      tick_size.each_with_index do |tsize, i|
+        n = ((amax - amin) / scale / tsize).truncate
+        if n > 7
+          tick = tick_size[i - 1]
+          break
+        end
       end
-      tick_size[i - 1] * scale
+      tick * scale
     end
 
     def legend_size
@@ -1271,6 +1564,11 @@ module GR
       create_plot(:step, *args)
     end
 
+    # (Plot) Draw one or more step or staircase plots.
+    def stairs(*args)
+      create_plot(:stairs, *args)
+    end
+
     # (Plot) Draw one or more scatter plots.
     def scatter(*args)
       create_plot(:scatter, *args)
@@ -1291,46 +1589,88 @@ module GR
       plt.plot_data
     end
 
+    # (Plot) Draw a heatmap.
     # (Plot) Draw a heatmap.
     def heatmap(*args)
-      # FIXME
-      args, kv = format_xyzc(*args)
-      _x, _y, z = args
-      ysize, xsize = z.shape
-      z = z.reshape(xsize, ysize)
+      kv = args.last.is_a?(Hash) ? args.pop : {}
+      if args.length == 1
+        z = args[0]
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+        ysize, xsize = z.shape
+        z = z.reshape(xsize, ysize)
+        x = (1..xsize).to_a
+        y = (1..ysize).to_a
+      elsif args.length == 3
+        x, y, z = args
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+      else
+        raise ArgumentError
+      end
       create_plot(:heatmap, kv) do |plt|
-        plt.kvs[:xlim] ||= [0.5, xsize + 0.5]
-        plt.kvs[:ylim] ||= [0.5, ysize + 0.5]
-        plt.args = [[(1..xsize).to_a, (1..ysize).to_a, z, nil, '']]
+        plt.args = [[x, y, z, nil, '']]
+      end
+    end
+
+    # (Plot) Draw a nonuniformheatmap.
+    def nonuniformheatmap(*args)
+      kv = args.last.is_a?(Hash) ? args.pop : {}
+      if args.length == 1
+        z = args[0]
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+        ysize, xsize = z.shape
+        z = z.reshape(xsize, ysize)
+        x = (1..xsize).to_a
+        y = (1..ysize).to_a
+      elsif args.length == 3
+        x, y, z = args
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+      else
+        raise ArgumentError
+      end
+      create_plot(:nonuniformheatmap, kv) do |plt|
+        plt.args = [[x, y, z, nil, '']]
       end
     end
 
     # (Plot) Draw a polarheatmap.
     def polarheatmap(*args)
-      d = args.shift
-      # FIXME
-      z = Numo::DFloat.cast(d)
-      raise 'expected 2-D array' unless z.ndim == 2
-
-      create_plot(:polarheatmap, z, *args) do |plt|
-        width, height = z.shape
-        plt.kvs[:xlim] ||= [0.5, width + 0.5]
-        plt.kvs[:ylim] ||= [0.5, height + 0.5]
-        plt.args = [[(1..width).to_a, (1..height).to_a, z, nil, '']]
+      kv = args.last.is_a?(Hash) ? args.pop : {}
+      if args.length == 1
+        z = args[0]
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+        ysize, xsize = z.shape
+        z = z.reshape(xsize, ysize)
+        x = (1..xsize).to_a
+        y = (1..ysize).to_a
+      elsif args.length == 3
+        x, y, z = args
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+      else
+        raise ArgumentError
+      end
+      create_plot(:polarheatmap, kv) do |plt|
+        plt.args = [[x, y, z, nil, '']]
       end
     end
 
     # (Plot) Draw a nonuniformpolarheatmap.
     def nonuniformpolarheatmap(*args)
-      # FIXME
-      args, kv = format_xyzc(*args)
-      _x, _y, z = args
-      ysize, xsize = z.shape
-      z = z.reshape(xsize, ysize)
+      kv = args.last.is_a?(Hash) ? args.pop : {}
+      if args.length == 1
+        z = args[0]
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+        ysize, xsize = z.shape
+        z = z.reshape(xsize, ysize)
+        x = (1..xsize).to_a
+        y = (1..ysize).to_a
+      elsif args.length == 3
+        x, y, z = args
+        z = Numo::DFloat.cast(z) if z.is_a?(Array)
+      else
+        raise ArgumentError
+      end
       create_plot(:nonuniformpolarheatmap, kv) do |plt|
-        plt.kvs[:xlim] ||= [0.5, xsize + 0.5]
-        plt.kvs[:ylim] ||= [0.5, ysize + 0.5]
-        plt.args = [[(1..xsize).to_a, (1..ysize).to_a, z, nil, '']]
+        plt.args = [[x, y, z, nil, '']]
       end
     end
 
@@ -1402,18 +1742,29 @@ module GR
     end
 
     # (Plot) Draw a bar plot.
-    def barplot(labels, heights, kv = {})
-      labels = labels.map(&:to_s)
-      wc, hc = barcoordinates(heights)
-      create_plot(:bar, labels, heights, kv) do |plt|
-        if kv[:horizontal]
+    def barplot(*args)
+      kv = args.last.is_a?(Hash) ? args.pop : {}
+      if args.length == 2
+        labels, heights = args
+      elsif args.length == 1
+        heights = args[0]
+        labels = (1..heights.length).map(&:to_s)
+      else
+        raise ArgumentError
+      end
+
+      wc, hc = barcoordinates(heights, kv)
+      horizontal = kv.delete(:horizontal)
+
+      create_plot(:bar, kv) do |plt|
+        if horizontal
           plt.args = [[hc, wc, nil, nil, '']]
           plt.kvs[:yticks] = [1, 1]
-          plt.kvs[:yticklabels] = labels
+          plt.kvs[:yticklabels] = labels.map(&:to_s)
         else
           plt.args = [[wc, hc, nil, nil, '']]
           plt.kvs[:xticks] = [1, 1]
-          plt.kvs[:xticklabels] = labels
+          plt.kvs[:xticklabels] = labels.map(&:to_s)
         end
       end
     end
@@ -1423,17 +1774,13 @@ module GR
       create_plot(:hist, series, kv) do |plt|
         nbins = plt.kvs[:nbins] || 0
         x, y = hist(series, nbins)
-        plt.args = if kv[:horizontal]
-                     [[y, x, nil, nil, '']]
-                   else
-                     [[x, y, nil, nil, '']]
-                   end
+        plt.args = [[x, y, nil, nil, '']]
       end
     end
 
     # (Plot) Draw an image.
     def imshow(img, kv = {})
-      img = Numo::DFloat.cast(img) # Umm...
+      img = Numo::DFloat.cast(img) unless img.is_a?(String)
       create_plot(:imshow, img, kv) do |plt|
         plt.args = [[nil, nil, img, nil, '']]
       end
@@ -1524,26 +1871,18 @@ module GR
     end
 
     def hist(x, nbins = 0)
-      nbins = (3.3 * Math.log10(x.length)).round + 1 if nbins <= 1
-      begin
-        require 'histogram/array'
-      rescue LoadError => e
-        e.message << " Please add gem 'histogram' to your project's Gemfile."
-        raise e
-      end
-      x = x.to_a if narray?(x)
-      x, y = x.histogram(nbins, bin_boundary: :min)
-      x.push(x[-1] + x[1] - x[0])
-      [x, y]
+      GR::Plot::Histogram.hist(x, nbins)
     end
 
-    def barcoordinates(heights, barwidth = 0.8, baseline = 0.0)
+    def barcoordinates(heights, kv = {})
+      barwidth = kv[:barwidth] || 0.8
+      baseline = kv[:baseline] || 0.0
       halfw = barwidth / 2.0
       wc = []
       hc = []
       heights.each_with_index do |value, i|
-        wc << i - halfw
-        wc << i + halfw
+        wc << (i + 1) - halfw
+        wc << (i + 1) + halfw
         hc << baseline
         hc << value
       end