plplot 0.0.0

data/examples/x18.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'rubygems'
+require 'plplot'
+include PLplot
+include Math
+
+# 3-d line and point plot demo.  Adapted from x08.rb.
+
+OPT = [ 1, 0, 1, 0 ]
+ALT = [ 20.0, 35.0, 50.0, 65.0 ]
+AZ  = [ 30.0, 40.0, 50.0, 60.0 ]
+
+TWO_PI = 2 * PI
+
+def theta(a)
+  TWO_PI * a / 20.0
+end
+
+def phi(a)
+  PI * a / 20.1
+end
+
+def test_poly(k)
+  draw = [
+    [ 1, 1, 1, 1 ],
+    [ 1, 0, 1, 0 ],
+    [ 0, 1, 0, 1 ],
+    [ 1, 1, 0, 0 ]
+  ]
+
+  x = NArray.float(5)
+  y = NArray.float(5)
+  z = NArray.float(5)
+
+  pladv(0)
+  plvpor(0.0, 1.0, 0.0, 0.9)
+  plwind(-1.0, 1.0, -0.9, 1.1)
+  plcol0(1)
+  plw3d(1.0, 1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, ALT[k], AZ[k])
+  plbox3("bnstu", "x axis", 0.0, 0,
+         "bnstu", "y axis", 0.0, 0,
+         "bcdmnstuv", "z axis", 0.0, 0)
+
+  plcol0(2)
+
+  # x = r sin(phi) cos(theta)
+  # y = r sin(phi) sin(theta)
+  # z = r cos(phi)
+  # r = 1 :=)
+
+  20.times do |i|
+    20.times do |j|
+      x[0] = sin(phi(j)) * cos(theta(i))
+      y[0] = sin(phi(j)) * sin(theta(i))
+      z[0] = cos(phi(j))
+
+      x[1] = sin(phi(j + 1)) * cos(theta(i))
+      y[1] = sin(phi(j + 1)) * sin(theta(i))
+      z[1] = cos(phi(j + 1))
+
+      x[2] = sin(phi(j + 1)) * cos(theta(i + 1))
+      y[2] = sin(phi(j + 1)) * sin(theta(i + 1))
+      z[2] = cos(phi(j + 1))
+
+      x[3] = sin(phi(j)) * cos(theta(i + 1))
+      y[3] = sin(phi(j)) * sin(theta(i + 1))
+      z[3] = cos(phi(j))
+
+      x[4] = sin(phi(j)) * cos(theta(i))
+      y[4] = sin(phi(j)) * sin(theta(i))
+      z[4] = cos(phi(j))
+
+      plpoly3(x, y, z, draw[k], 1)
+    end
+  end
+
+  plcol0(3)
+  plmtex("t", 1.0, 0.5, 0.5, "unit radius sphere")
+
+end
+
+#--------------------------------------------------------------------------\
+# Does a series of 3-d plots for a given data set, with different
+# viewing options in each plot.
+#--------------------------------------------------------------------------/
+
+NPTS = 1000
+
+# Parse and process command line arguments
+
+PLOptionParser.parse!
+
+# Initialize plplot
+
+plinit
+
+4.times do |k|
+  test_poly(k)
+end
+
+x = NArray.float(NPTS)
+y = NArray.float(NPTS)
+z = NArray.float(NPTS)
+
+# From the mind of a sick and twisted physicist...
+
+NPTS.times do |i|
+  z[i] = -1.0 + 2.0 * i / NPTS
+
+  # Pick one ...
+
+  #	r = 1.0 - (i.to_f / NPTS)
+  r = z[i]
+
+  x[i] = r * cos(2.0 * PI * 6.0 * i / NPTS)
+  y[i] = r * sin(2.0 * PI * 6.0 * i / NPTS)
+end
+
+4.times do |k|
+  pladv(0)
+  plvpor(0.0, 1.0, 0.0, 0.9)
+  plwind(-1.0, 1.0, -0.9, 1.1)
+  plcol0(1)
+  plw3d(1.0, 1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, ALT[k], AZ[k])
+  plbox3("bnstu", "x axis", 0.0, 0,
+         "bnstu", "y axis", 0.0, 0,
+         "bcdmnstuv", "z axis", 0.0, 0)
+
+  plcol0(2)
+
+  if OPT[k] != 0
+    plline3(x, y, z)
+  else
+    plpoin3(x, y, z, 1)
+  end
+
+  plcol0(3)
+  title = sprintf("#frPLplot Example 18 - Alt=%.0f, Az=%.0f",
+                  ALT[k], AZ[k])
+  plmtex("t", 1.0, 0.5, 0.5, title)
+end
+
+# Clean up
+plend

data/examples/x20.rb

@@ -0,0 +1,360 @@
+#!/usr/bin/env ruby
+$-w = true if $0 == __FILE__
+
+require 'scanf'
+require 'rubygems'
+require 'plplot'
+include PLplot
+include Math
+
+# plimage demo
+
+XDIM = 260
+YDIM = 220
+
+StretchData = Struct.new(
+    :xmin, :xmax, :ymin, :ymax,
+    :stretch
+)
+
+# Defaults for user options.  Use global variables to track user options since
+# that matches the C example most closely.
+
+$dbg           = false
+$nosombrero    = false
+$nointeractive = false
+$f_name        = nil
+
+PLOP = PLOptionParser.new do |op|
+  op.separator('')
+  op.separator('x20 options:')
+  op.on('--dbg', "Extra debugging plot") do
+    $dbg = true
+  end
+  op.on('--nosombrero', "No sombrero plot") do
+    $nosombrero = true
+  end
+  op.on('--nointeractive', "No interactive selection") do
+    $nointeractive = true
+  end
+  op.on('--save FILENAME', "Save sombrero plot in color", "postscript file FILENAME") do |o|
+    $f_name = o
+  end
+end
+
+# Transformation function
+def mypltr(x, y, s)
+    x0  = (s.xmin + s.xmax) * 0.5
+    y0  = (s.ymin + s.ymax) * 0.5
+    dy  = (s.ymax - s.ymin) * 0.5
+    tx = x0 + (x0 - x) * (1.0 - s.stretch * cos((y - y0) / dy * PI * 0.5))
+    [tx, y]
+end
+
+# read image from file in binary ppm format
+def read_img(fname)
+  imf = nil
+  num_col = nil
+
+  # naive grayscale binary ppm reading. If you know how to, improve it
+  open(fname, "rb") do |fp|
+
+    ver= fp.scanf("%s\n")[0]
+
+    if ver.nil? || ver != 'P5'
+      raise "unrecognized file format version"
+    end
+    # puts("version: #{ver}")
+
+    while ((c = fp.getc) == ?#) do
+      fp.gets # comments
+    end
+    fp.ungetc(c)
+
+    w, h, num_col = fp.scanf("%d%d%d\n") # width, height num colors
+    raise 'unrecognized file format dimensions' if num_col.nil?
+    # printf("width=%d height=%d num_col=%d\n", w, h, num_col)
+
+    # This is potentially problematic since read will read _upto_ w*h bytes,
+    # but it is not guaranteed to read _exactly_ w*h bytes.
+    img = fp.read(w*h) rescue ''
+    raise 'file size error' if img.size != w*h
+
+    imf = NArray.to_na(img, NArray::BYTE, w, h).transpose(1,0).to_type(NArray::FLOAT)
+
+    # flip image up-down
+    w.times do |i|
+      (h/2).times do |j|
+        imf[j,i], imf[-1-j,i] = imf[-1-j,i], imf[j,i]
+      end
+    end
+  end
+
+  [imf, num_col]
+end
+
+# save plot
+def save_plot(fname)
+    cur_strm = plgstrm    # get current stream
+    new_strm = plmkstrm   # create a new one
+
+    plsdev("psc")         # new device type. Use a known existing driver
+    plsfnam(fname)        # file name
+
+    plcpstrm(cur_strm, 0) # copy old stream parameters to new stream
+    plreplot              # do the save
+    plend1                # close new device
+
+    plsstrm(cur_strm)     # and return to previous one
+end
+
+# get selection square interactively
+def get_clip
+  # enter xor mode to draw a selection rectangle
+  return nil unless plxormod(1)
+
+  gin = nil
+  start = false
+  sx = NArray.float(5)
+  sy = NArray.float(5)
+
+  loop do
+    plxormod(0)
+    gin = plGetCursor
+    next unless gin
+    plxormod(1)
+
+    if (gin.button == 1)
+      xxi = gin.wx; yyi = gin.wy
+      if (start)
+        plline(sx, sy) # clear previous rectangle
+      end
+
+      start = false
+
+      sx[0] = xxi; sy[0] = yyi
+      sx[4] = xxi; sy[4] = yyi
+    end
+
+    if gin.state & 0x100 != 0
+      xxe = gin.wx; yye = gin.wy
+      if start 
+        plline(sx, sy) # clear previous rectangle
+      end
+
+      start = true
+
+      sx[2] = xxe;   sy[2] = yye
+      sx[1] = xxe;   sy[1] = sy[0]
+      sx[3] = sx[4]; sy[3] = yye
+      plline(sx, sy) # draw new rectangle
+    end
+
+    if (gin.button == 3 || gin.keysym == PLK::Return || gin.keysym == 'Q')
+      if start
+        plline(sx, sy) # clear previous rectangle
+      end
+      break
+    end
+  end
+
+  plxormod(0) # leave xor mod
+
+  xi = sx[0]
+  xe = sx[1]
+  if (xe < xi)
+    xi, xe = xe, xi
+  end
+
+  yi = sy[0]
+  ye = sy[3]
+  if (yi < ye)
+    yi, ye = ye, yi
+  end
+
+  gin.keysym == 'Q' ? nil : [xi, xe, yi, ye]
+end
+
+# set gray colormap
+def gray_cmap(num_col)
+  v = [0, 1]
+  plscmap1n(num_col)
+  plscmap1l(1, v, v, v, v)
+end
+
+#---------
+# main
+#---------
+
+# Bugs in plimage():
+# -at high magnifications, the left and right edge are ragged, try
+#    ./x20c -dev xwin -wplt 0.3,0.3,0.6,0.6 -ori 0.5
+#
+# Bugs in x20c.c:
+# -if the window is resized after a selection is made on "lena", when
+#  making a new selection the old one will re-appear.
+
+# Parse and process command line arguments
+
+PLOP.parse!
+
+# Initialize plplot
+
+plinit()
+
+z = NArray.float(YDIM, XDIM)
+
+# view image border pixels
+if $dbg
+  plenv(1, XDIM, 1, YDIM, 1, 1) # no plot box
+
+  # build a one pixel square border, for diagnostics
+  XDIM.times do |i|
+    z[-1,i] = 1 # right
+    z[ 0,i] = 1 # left
+  end
+
+  YDIM.times do |i|
+    z[i, 0] = 1 # top
+    z[i,-1] = 1 # botton
+  end
+
+  pllab("...around a blue square.", " ", "A red border should appear...")
+
+  plimage(z, 1..XDIM, 1..YDIM, 0..0, 1..XDIM, 1..YDIM)
+end
+
+# sombrero-like demo
+if !$nosombrero
+  plcol0(2) # draw a yellow plot box, useful for diagnostics! :(
+  plenv(0, 2 * PI, 0, 3 * PI, 1, -1)
+
+  XDIM.times do |i|
+    x = i * 2 * PI / (XDIM - 1)
+    YDIM.times do |j|
+      y = j * 3 * PI / (YDIM - 1)
+      r = sqrt(x * x + y * y) + 1e-3
+      z[j,i] = sin(r) / r
+    end
+  end
+
+  pllab("No, an amplitude clipped \"sombrero\"", "", "Saturn?")
+  plptex(2, 2, 3, 4, 0, "Transparent image")
+  plimage(z, 0..2*PI, 0..3*PI, 0.05..1, 0..2*PI, 0..3*PI)
+
+  # save the plot
+  if $f_name
+    save_plot($f_name)
+  end
+end
+
+# read Lena image
+# Note we try three different locations to cover the case where this
+# examples is being run from the test_c.sh script
+begin
+  img_f, num_col = read_img(File.join(File.dirname($0), "lena.pgm"))
+rescue IOError
+  begin
+    img_f, num_col = read_img("lena.pgm")
+  rescue IOError
+    begin
+      img_f, num_col = read_img("../lena.pgm")
+    rescue
+      plend
+      raise
+    end
+  end
+end
+
+height, width = img_f.shape
+
+# set gray colormap
+gray_cmap(num_col)
+
+# display Lena
+plenv(1, width, 1, height, 1, -1)
+
+if !$nointeractive
+  pllab("Set and drag Button 1 to (re)set selection, Button 2 to finish.", " ", "Lena...")
+else
+  pllab("", " ", "Lena...")
+end
+
+plimage(img_f, 1..width, 1..height, 0..0, 1..width, 1..height)
+
+# selection/expansion demo
+if !$nointeractive
+  xi, xe, yi, ye = get_clip # get selection rectangle
+  if xi.nil?
+    plend
+    exit 0
+  end
+
+  # If empty selection
+  if xi == xe || yi == ye
+    xi = 200; xe = 330
+    yi = 280; ye = 220
+  end
+
+  # I'm unable to continue, clearing the plot and advancing to the next
+  # one, without hiting the enter key, or pressing the button... help!
+  #
+  # Forcing the xwin driver to leave locate mode and destroying the
+  # xhairs (in GetCursorCmd()) solves some problems, but I still have
+  # to press the enter key or press Button-2 to go to next plot, even
+  # if a pladv() is not present!  Using plbop() solves the problem, but
+  # it shouldn't be needed!
+
+  # plbop
+
+  # plspause(0), pladv(0), plspause(1), also works,
+  # but the above question remains.
+  # With this approach, the previous pause state is lost,
+  # as there is no API call to get its current state.
+
+  plspause(0)
+  pladv(0)
+
+  # display selection only
+  plimage(img_f, 1..width, 1..height, 0..0, xi..xe, ye..yi)
+
+  plspause(1)
+
+  # zoom in selection
+  plenv(xi, xe, ye, yi, 1, -1)
+  plimage(img_f, 1..width, 1..height, 0..0, xi..xe, ye..yi)
+end
+
+# Base the dynamic range on the image contents.
+img_min, img_max = plMinMax2dGrid(img_f)
+
+# Draw a saturated version of the original image.  Only use the middle 50%
+# of the image's full dynamic range.
+plcol0(2)
+plenv(0, width, 0, height, 1, -1)
+pllab("", "", "Reduced dynamic range image example")
+plimage(img_f, 0..width, 0..height, 0..0, (img_min + img_max * 0.25)..(img_max - img_max * 0.25))
+
+# Draw a distorted version of the original image, showing its full dynamic range.
+plenv(0, width, 0, height, 1, -1)
+pllab("", "", "Distorted image example")
+
+stretch = StretchData.new(0, width, 0, height, 0.5)
+
+# Use custom transformation.  This is slower than pltr2, but it does work.  It
+# is commented out for consistency with x20c.c.
+#plimage(img_f, 0..width, 0..height, 0..0, img_min..img_max) {|x,y| mypltr(x,y,stretch)}
+
+# Use pltr2 transformation (fast)
+xg = NArray.float(height+1, width+1)
+yg = NArray.float(height+1, width+1)
+
+(0..width).each do |i|
+  (0..height).each do |j|
+    xg[j,i], yg[j,i] = mypltr(i, j, stretch)
+  end
+end
+
+plimage(img_f, 0..width, 0..height, 0..0, img_min..img_max, xg, yg)
+
+plend