shapelib 0.7.0

data/lib/shapelib.rb

@@ -0,0 +1,2 @@
+require 'shapelib_ext'
+require 'shapelib/shape'

data/lib/shapelib/shape.rb

@@ -0,0 +1,14 @@
+module Shapelib
+  class Shape
+    def each
+      latlngs.each do |l|
+        yield l
+      end
+    end
+    
+    def latlngs
+      @latlngs ||= yvals.zip(xvals)
+    end
+  end
+end
+      

data/lib/shapelib/version.rb

@@ -0,0 +1,3 @@
+module Shapelib
+  VERSION = "0.7.0"
+end

data/test/libtest.rb

@@ -0,0 +1,80 @@
+class AssertFail < Exception
+end
+
+def assert(a, b)
+    caller = ""
+    begin
+	raise "no problem"
+    rescue RuntimeError => e
+	caller = e.backtrace[1]
+    end
+    if (b === a) then
+	val = b.inspect
+	val = "#{val}..." if val.size > 40
+	print "ok #{caller}: #{val}\n" if $VERBOSE
+    else
+	val = a.inspect
+	val = "#{val}..." if val.size > 200
+	raise AssertFail, val
+    end
+end
+
+def file_delete(*args)
+    for file in args
+	next unless File.exist?(file)
+	File.delete(file)
+    end
+end
+
+def fold_line(line)
+    buf = ""
+    while line
+	head = line[0..63]
+	buf << (head + "\n")
+	line = line[64..-1]
+    end
+    buf
+end
+
+def assert_file(filename, pat)
+    f = File.read(filename)
+    r = [pat.gsub(/\s+/, "")].pack('H*')
+
+    if (r === f) then
+	print "ok <#{filename}>\n" if $VERBOSE
+    else
+	for i in 0...(f.size)
+	    next if (f[i] == r[i])
+	    printf "ofs=%08x file=%02x expected=%02x\n", i, f[i], r[i]
+	    break
+	end
+	print "#{filename} is longer than expected\n" if f.size > r.size
+	h = f.unpack('H*').first
+	File.open("#{filename}.hex", "w") { |fp| fp.write(fold_line(h)) }
+	print "hex dump of <#{filename}> is saved to <#{filename}.hex>.\n"
+	raise AssertFail
+    end
+end
+
+def testblock(title)
+    begin
+	yield
+    rescue Exception => e
+	print "#{title} failed: #{e.message} (#{e.class.to_s})\n"
+	print "| ", e.backtrace[1..-1].join("\n| "), "\n"
+	return 1
+    else
+	print "#{title} ok\n"
+	return 0
+    end
+end
+
+def tainttest(msg)
+    begin
+	yield
+    rescue SecurityError => e
+	assert(e.message, msg)
+    else
+	raise SecurityError, "<#{msg}> doesn't come" if $SAFE > 0
+    end
+end

data/test/zsample1.rb

@@ -0,0 +1,168 @@
+require 'shapelib'
+
+class Sample1
+    include ShapeLib
+    
+    def initialize
+    end
+
+    def layer1
+	fp = ShapeFile.new('ts1stn.shp', :Point)
+	fp.add_field 'name', :String, 24
+	fp.add_field 'wdir', :String, 6 # 4
+	fp.add_field 'wspd', :Integer, 6 # 2
+	fp.add_field 'weather', :String, 16
+	fp.add_field 'pres', :Integer, 6 # 4
+	fp.add_field 'temp', :Integer, 6 # 3
+	fp.write new_point(124.17, 24.33,
+	    'name' => 'Ishigakijima', 'wdir' => 'S', 'wspd' => 3,
+	    'weather' => 'shower', 'pres' => 1014, 'temp' => 24)
+	csv = <<EOF
+127:41.1, 26:12.4, Naha, S, 4, partly cloudy, 1015, 21
+131.23, 25.83, Minamidaito Jima, SSW, 2, partly cloudy, 1017, 20
+129:29.7, 28:22.7, Naze, SW, 2, partly cloudy, 1017, 20
+130.72, 31.80, Kagoshima, WSW, 1, shower, 1013, 18
+128:49.6, 32:41.6, Fukue, NNE, 3, cloudy, 1014, 11
+129:17.5, 34:11.8, Izuhara, NNW, 2, cloudy, 1016, 10
+133:00.6, 32:43.3, Ashizuri Misaki, W, 2, cloudy, 1011, 17
+134:10.6, 33:15.1, Muroto Misaki, NNE, 3, fog, 1012, 13
+132:46.6, 33:50.6, Matsuyama, SE, 1, rain, 1014, 10
+132:04.2, 34:53.8, Hamada, ENE, 1, cloudy, 1015, 8
+133.3, 36.2, Saigo, NNE, 2, shower, 1016, 7
+135.6, 34.7, Osaka, NNE, 2, cloudy, 1014, 9
+135:45.6, 33:27.0, Shio no Misaki, NE, 1, shower, 1012, 13
+139.8, 33.1, Hachijo Jima, SW, 4, shower, 1013, 18
+139.4, 34.8, Izu Oshima, NNE, 4, shower, 1014, 9
+138:12.7, 34:36.2, Omaezaki, NE, 2, rain, 1012, 12
+140:51.4, 35:44.3, Choshi, NNE, 5, rain, 1014, 7
+139:03.6, 36:24.3, Maebashi, WNW, 1, rain, 1015, 8
+140:54.2, 36:56.8, Onahama, N, 3, rain, 1017, 5
+136:53.7, 37:23.5, Wajima, ENE, 1, rain, 1016, 5
+138:14.3, 38:01.7, Aikawa, SE, 2, rain, 1016, 4
+140.9, 38.2, Sendai, NNW, 1, snow-rain, 1018, 1
+141:57.9, 39:38.8, Miyako, N, 2, snow, 1020, 1
+140.2, 39.6, Akita, NNE, 1, cloudy, 1018, 0
+140.8, 41.8, Hakodate, NNE, 3, cloudy, 1019, -4
+142:46.6, 42:09.7, Urakawa, NNE, 2, cloudy, 1019, -5
+145:35.1, 43:19.8, Nemuro, CALM, 0, cloudy, 1019, -5
+141:40.7, 45:24.9, Wakkanai, W, 3, cloudy, 1018, -4
+151, 46, Poronaisk, W, 3, cloudy, 1018, -4
+156, 50, Severo-Kurilsk, WSW, 3, partly cloudy, 1014, -16
+135.17, 48.52, Habarovsk, CALM, 0, partly cloudy, 1014, -19
+135:48, 44:21, Rudnaya Pristan, W, 1, cloudy, 1019, -13
+131.93, 43.12, Vladivostok, SE, 3, cloudy, 1018, -5
+126.97, 37.57, Seoul, NNE, 1, partly cloudy, 1019, 1
+131, 37, Ulleung-do, NE, 1, cloudy, 1018, 3
+128.93, 35.18, Pusan, NNE, 3, cloudy, 1016, 6
+127, 35, Mokpo, NNE, 3, cloudy, 1019, 3
+126.50, 33.50, Cheju-do, NNE, 1, cloudy, 1017, 9
+121.55, 25.07, Taipei, ESE, 1, cloudy, 1013, 21
+120.35, 22.58, Kaohsiung, N, 1, cloudy, 1013, 24
+125.22, 43.90, Changchun, WNW, 3, clear, 1024, -13
+116.28, 39.93, Beijing, NNW, 4, partly cloudy, 1031, -2
+121.63, 38.90, Dalian, NNW, 3, partly cloudy, 1024, -1
+120.33, 36.07, Qingdao, NNW, 4, fog, 1024, 2
+121.4, 31.2, Shanghai, N, 3, rain, 1021, 7
+114.13, 30.62, Wuhan, NNW, 2, rain, 1025, 8
+118.08, 24.48, Xiamen, CALM, 0, fog, 1014, 18
+114.02, 22.20, Hong Kong, ESE, 2, partly cloudy, 1014, 21
+120.53, 18.18, Laoag, CALM, 0, clear, 1012, 22
+121.00, 14.52, Manila, WNW, 1, partly cloudy, 1013, 25
+142.18, 27.08, Chichi Jima, NW, 1, clear, 1020, 16
+133.97, 24.30, Minami Tori Shima, E, 4, X, 1021, 23
+138:43.6, 35:21.6, Fujisan, X, X, X, X, -4
+126, 29, SHIP,  NW, 5, rain, 1015, X
+148, 21, SHIP,   E, 3, cloudy, 1018, X
+139, 31, SHIP,  SW, 7, partly cloudy, 1016, X
+136, 39, SHIP, ENE, 5, partly cloudy, 1017, X
+146, 36, SHIP, ENE, 5, rain, 1013, X
+EOF
+	for line in csv.split(/\n/)
+	    x, y, name, wdir, wspd, weather, pres, temp = line.split(/, */)
+	    x = $1.to_i + $2.to_f / 60 if /(\d+):(\d+(\.\d)?)/ === x
+	    y = $1.to_i + $2.to_f / 60 if /(\d+):(\d+(\.\d)?)/ === y
+	    x = Float(x)
+	    y = Float(y)
+	    wdir = nil if wdir == 'X'
+	    weather = nil if weather == 'X'
+	    wspd = (wspd == 'X' ? nil : Integer(wspd))
+	    pres = (pres == 'X' ? nil : Integer(pres))
+	    temp = (temp == 'X' ? nil : Integer(temp))
+	    fp.write new_point(x, y,
+		'name' => name, 'wdir' => wdir, 'wspd' => wspd,
+		'weather' => weather , 'pres' => pres, 'temp' => temp)
+	end
+	fp.close
+    end
+
+    def layer2
+	fp = ShapeFile.new('ts1sys.shp', :Point)
+	fp.add_field 'class', 'String', 16
+	fp.add_field 'symbol', 'String', 3
+	fp.add_field 'pres', 'Integer', 4
+	fp.add_field 'dir', 'String', 4
+	fp.add_field 'speed', 'Integer', 3
+	fp.write new_point(169, 45, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 992, 'dir' => 'NNE', 'speed' => 20)
+	fp.write new_point(177, 58, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 996, 'dir' => 'N', 'speed' => 10)
+	fp.write new_point(130, 41, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 1016, 'dir' => 'ENE', 'speed' => 10)
+	fp.write new_point(134, 33, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 1012, 'dir' => 'ENE', 'speed' => 20)
+	fp.write new_point(152, 57, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 1000, 'dir' => 'WSW', 'speed' => 5)
+	fp.write new_point(156, 48, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 1004, 'dir' => 'E', 'speed' => 10)
+	fp.write new_point(139,  3, 'class' => 'Low', 'symbol' => 'L',
+	    'pres' => 1008, 'dir' => 'STNR', 'speed' => 0)
+	fp.write new_point(138, 43, 'class' => 'High', 'symbol' => 'H',
+	    'pres' => 1020, 'dir' => 'E', 'speed' => 15)
+	fp.write new_point(164, 29, 'class' => 'High', 'symbol' => 'H',
+	    'pres' => 1024, 'dir' => 'E', 'speed' => 20)
+	fp.close
+    end
+
+    def layer3
+	fp = ShapeFile.new('ts1frnt.shp', :Arc)
+	fp.add_field 'class', 'String', 16
+
+	arc = Arc.new [[169, 45], [172, 44], [175, 41]]
+	arc['class'] = 'occlusion'
+	fp.write arc
+
+	arc = Arc.new [[175, 41], [177, 39], [178, 37]]
+	arc['class'] = 'warm'
+	fp.write arc
+
+	arc = Arc.new [[175, 41], [171, 38], [164, 36]]
+	arc['class'] = 'cold'
+	fp.write arc
+
+	arc = Arc.new [[119, 27], [128, 29], [134, 33], [139, 34],
+	    [142, 35], [150, 35]]
+	arc['class'] = 'stationary'
+	fp.write arc
+
+	fp.close
+    end
+
+    def layer4
+	fp = ShapeFile.new('ts1isop.shp', :Arc)
+	fp.add_field 'pres', 'Integer', 4
+	arc = Arc.new [[168, 19], [150, 18], [141, 19], [129, 22], [133, 29], [147, 34], [149, 36], [141, 37], [128, 34], [122, 28], [110, 25]]
+	arc['pres'] = 1016
+	fp.write arc
+	fp.close
+    end
+
+    def run
+	layer1
+	layer2
+	layer3
+	layer4
+    end
+
+end
+
+Sample1.new.run

data/test/ztest1.rb

@@ -0,0 +1,253 @@
+require 'shapelib'
+require 'libtest.rb'
+
+def test1
+    testblock('test1') do 
+	file_delete(*%w(test1.dbf test1.shp test1.shx))
+	s = ShapeLib::ShapeFile.new('test1.shp', :Point, [["id", :Integer, 8]])
+	assert(s.field_count, 1)
+	s.add_field 'name', ShapeLib::String, 12
+	assert(s.field_count, 2)
+	assert(s.field_index('name'), 1)
+	assert(s.field_type('name'), :String)
+	assert(s.field_type(1), :String)
+	s.add_field 'k', ShapeLib::Integer, 3
+	assert(s.field_count, 3)
+	s.add_field 'y', "Float", 8, 3
+	assert(s.field_index('y'), 3)
+	assert(s.field_type('y'), :Float)
+	assert(s.field_count, 4)
+	assert(s.size, 0)
+
+	shape = ShapeLib::Point.new(100, 101, 'id' => 234)
+	shape['name'] = 'foo'
+	shape['k'] = 18
+	fval = shape['y'] = 31.415926
+	assert(s.write(shape), 0)
+	assert(s.size, 1)
+	assert(shape.x, 100.0)
+
+	assert(s.fields, %w(id name k y))
+	assert(s.field_type(1), :String)
+	assert(s.field_name(1), 'name')
+
+	assert(shape['id'], 234)
+	assert(shape['name'], 'foo')
+	assert(shape['k'], 18)
+	assert(shape['y'], fval)
+	assert(shape['unspecified'], nil)
+
+	shape = ShapeLib.new_point(200, 201)
+	assert(s.write(shape), 1)
+	assert(s.size, 2)
+
+	assert(shape['id'], nil)
+	assert(shape.x, 200.0)
+
+	shape = s.read(0)
+	assert(shape.shape_id, 0)
+	assert(shape['id'], 234)
+	assert(shape['name'], 'foo')
+	assert(shape['k'], 18)
+	# note that only 3 digits after decimal point is conserved.
+	assert(shape['y'], 31.416)
+	assert(shape['unspecified'], nil)
+	assert(shape['unspecified2'], nil)
+
+	assert s.maxbound, [200, 201, 0, 0]
+
+	s.close
+
+	assert_file 'test1.dbf', <<EOF
+035f071a02000000a10020000000000000000000000000000000000000000000
+69640000000000000000004e0000000008000000000000000000000000000000
+6e616d650000000000000043000000000c000000000000000000000000000000
+6b000000000000000000004e0000000003000000000000000000000000000000
+79000000000000000000004e0000000008030000000000000000000000000000
+0d202020202020323334666f6f202020202020202020203138202033312e3431
+36202a2a2a2a2a2a2a2a0000000000000000000000002a2a2a2a2a2a2a2a2a2a
+2a
+EOF
+	assert_file 'test1.shp', <<EOF
+0000270a00000000000000000000000000000000000000000000004ee8030000
+0100000000000000000059400000000000405940000000000000694000000000
+0020694000000000000000000000000000000000000000000000000000000000
+00000000000000010000000a0100000000000000000059400000000000405940
+000000020000000a0100000000000000000069400000000000206940
+EOF
+	assert_file 'test1.shx', <<EOF
+0000270a00000000000000000000000000000000000000000000003ae8030000
+0100000000000000000059400000000000405940000000000000694000000000
+0020694000000000000000000000000000000000000000000000000000000000
+00000000000000320000000a000000400000000a
+EOF
+
+	file_delete(*%w(test1.dbf test1.shp test1.shx))
+    end
+end
+
+def test2
+    testblock('test2') do 
+	file_delete(*%w(test2.dbf test2.shp test2.shx))
+	s = ShapeLib::ShapeFile.new('test2.shp', ShapeLib::PointM)
+	assert(s.class.to_s, "ShapeLib::ShapeFile")
+	assert(s.field_count, 0)
+	s.add_field 'name', ShapeLib::String, 12
+	assert(s.field_count, 1)
+	assert(s.size, 0)
+
+	shape = ShapeLib.new_point(301, 302, 303)
+	assert(shape.class.to_s, "ShapeLib::PointM")
+	s.write(shape)
+	assert(s.size, 1)
+	assert(shape.m, 303)
+
+	shape = ShapeLib::PointM.new(401, 402, 403)
+	assert(shape.class.to_s, "ShapeLib::PointM")
+	s.write(shape)
+	assert(s.size, 2)
+
+	s.close
+	assert_file 'test2.shp', <<EOF
+0000270a000000000000000000000000000000000000000000000056e8030000
+150000000000000000d072400000000000e07240000000000010794000000000
+00207940000000000000000000000000000000000000000000f0724000000000
+00307940000000010000000e150000000000000000d072400000000000e07240
+0000000000f07240000000020000000e15000000000000000010794000000000
+002079400000000000307940
+EOF
+
+        sx = ShapeLib::ShapeFile.open('test2.shp')
+	assert sx.shape_type, :PointM
+	assert sx.minbound, [301.0, 302.0, 303.0, 0]
+	assert sx.maxbound, [401.0, 402.0, 403.0, 0]
+	sx.close
+
+	file_delete(*%w(test2.dbf test2.shp test2.shx))
+    end
+end
+
+def testA1
+    testblock('testA1') do 
+	file_delete(*%w(testa1.dbf testa1.shp testa1.shx))
+	s = ShapeLib::ShapeFile.new('testa1.shp', "Arc")
+	assert(s.class.to_s, "ShapeLib::ShapeFile")
+	assert(s.field_count, 0)
+	s.add_field 'name', ShapeLib::String, 12
+	assert(s.field_count, 1)
+	assert(s.size, 0)
+	
+	p1 = ShapeLib.new_point(1.1, 1.2)
+	p2 = ShapeLib.new_point(2.1, 2.2)
+	p3 = ShapeLib.new_point(3.1, 3.2)
+	shape = ShapeLib::Arc.new([p1, p2, p3])
+	assert(shape.class.to_s, 'ShapeLib::Arc')
+	assert(shape.n_parts, 1)
+	assert(shape.n_vertices, 3)
+	assert(shape.shape_id, nil)
+	assert(shape.shape_type, :Arc)
+	assert(s.write(shape), 0)
+
+	arc2 = [[101, 102], [111, 112], [121, 122]]
+	shape = ShapeLib::Arc.new([p1, p3], arc2)
+	assert(shape.n_parts, 2)
+	assert(s.write(shape), 1)
+
+	assert(shape.shape_id, nil)
+	assert(s.read(1).shape_id, 1)
+
+	file_delete(*%w(testa1.dbf testa1.shp testa1.shx))
+    end
+end
+
+def test3
+    testblock('test3') do
+	pt = ShapeLib::Point.new 4324434.13545, 3495423412.4324324
+	assert(pt.wkt, "POINT(4324434.135 3495423412)")
+	assert(pt.part_type, nil)
+	mp = ShapeLib::MultiPoint.new [1, 2], [3, 4], [5, 6]
+	assert(mp.wkt, "MULTIPOINT(1 2, 3 4, 5 6)")
+
+	ar = ShapeLib::Arc.new [1, 2], [3, 4], [5, 6]
+	assert(ar.wkt, "LINESTRING(1 2, 3 4, 5 6)")
+	assert(ar.xvals, [1, 3, 5])
+	assert(ar.yvals, [2, 4, 6])
+	ar = ShapeLib::Arc.new([[1, 2], [3, 4], [5, 6]])
+	assert(ar.wkt, "LINESTRING(1 2, 3 4, 5 6)")
+	ar = ShapeLib::Arc.new([[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10]])
+	assert(ar.wkt, "MULTILINESTRING((1 2, 3 4, 5 6), (7 8, 9 10))")
+	assert ar.xvals, [1, 3, 5, 7, 9]
+
+	ar2 = ShapeLib::Shape.new(arh = ar.to_h)
+	assert(ar2.class.to_s, "ShapeLib::Arc")
+	assert(ar2.to_h, arh)
+	assert(ar2.wkt, ar.wkt)
+
+	arm = ShapeLib::ArcM.new [1, 2, 3], [4, 5, 6], [7, 8, 9]
+	assert arm.mvals, [3, 6, 9]
+	arm = ShapeLib::ArcM.new [1, 2], [4, 5], [7, 8]
+	assert arm.mvals, [nil, nil, nil]
+
+	pl = ShapeLib::Polygon.new [1, 2], [3, 4], [5, 6.5], [1, 2]
+	assert(pl.wkt, "POLYGON((1 2, 3 4, 5 6.5, 1 2))")
+	assert(pl.rewind_polygon, true)
+	assert(pl.wkt, "POLYGON((1 2, 5 6.5, 3 4, 1 2))")
+	pl = ShapeLib::Polygon.new [[1, 2], [3, 4], [5, 6.5], [1, 2]]
+	assert(pl.wkt, "POLYGON((1 2, 3 4, 5 6.5, 1 2))")
+	pl = ShapeLib::Polygon.new([[1, 2], [3, 4], [5, 6.5], [1, 2]],
+	    [[7, 8], [9, 10], [11, 12.5], [7, 8]])
+	assert(pl.part_type, [:Ring, :Ring])
+	assert(pl.wkt,
+	    "POLYGON((1 2, 3 4, 5 6.5, 1 2), (7 8, 9 10, 11 12.5, 7 8))")
+
+	pl['abbrev'] = 'WI'
+	pl['state'] = 'Wisconsin'
+	pl['update'] = '2006-02-16'
+	assert ShapeLib::Shape.new(pl.to_h).to_h, pl.to_h
+
+	mq = ShapeLib::MultiPatch.new :OuterRing, [1, 2], [3, 4], [5, 6.5], [1, 2]
+	assert(mq.wkt, "POLYGON((1 2, 3 4, 5 6.5, 1 2))")
+    end
+end
+
+def test4
+    testblock('test4') do 
+	file_delete(*%w(test4.dbf test4.shp test4.shx))
+	s = ShapeLib::ShapeFile.new('test4.shp', :PointM)
+	assert(s.class.to_s, "ShapeLib::ShapeFile")
+	assert(s.field_count, 0)
+	assert(s.size, 0)
+	# shape = ShapeLib.new_point(301, 302, 303, 'foo' => 123)
+	shape = ShapeLib.new_point(301, 302, 303)
+	assert(s.write(shape), 0)
+	shape = ShapeLib::PointM.new(401, 402, 403)
+	assert(s.write(shape), 1)
+	s.close
+
+	fp = ShapeLib::ShapeFile.open('test4')
+	assert fp.size, 2
+	shape = fp.read(0)
+	assert(shape.class.to_s, "ShapeLib::Shape")
+	assert fp.size, 2
+	fp.close
+
+	ShapeLib::ShapeFile.open('test4.shp') do |fp|
+	    shape = fp.read
+	    assert(shape.shape_id, 0)
+	    shape = fp.read
+	    assert(shape.shape_id, 1)
+	    assert(fp.read, nil)
+	    i = 0
+	    fp.each do |shape|
+		assert shape.shape_id, i
+		i += 1
+	    end
+	    assert i, 2
+	end
+
+	file_delete(*%w(test4.dbf test4.shp test4.shx))
+    end
+end
+
+
+exit(test1 + test2 + testA1 + test3 + test4)