carray 1.3.6 → 1.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,13 +0,0 @@
1
- require 'mkmf'
2
-
3
- dir_config("carray", "../..", "../..")
4
-
5
- have_header("carray.h")
6
-
7
- if /cygwin|mingw/ =~ RUBY_PLATFORM
8
- have_library("carray")
9
- end
10
-
11
- create_makefile("carray/carray_imagemap")
12
-
13
-
@@ -1 +0,0 @@
1
- autoload :ImageMap, 'carray/graphics/imagemap'
@@ -1,273 +0,0 @@
1
- # ----------------------------------------------------------------------------
2
- #
3
- # carray/graphics/imagemap.rb
4
- #
5
- # This file is part of Ruby/CArray extension library.
6
- # You can redistribute it and/or modify it under the terms of
7
- # the Ruby Licence.
8
- #
9
- # Copyright (C) 2005 Hiroki Motoyoshi
10
- #
11
- # ----------------------------------------------------------------------------
12
-
13
- require 'carray'
14
-
15
- #
16
- # CArray#index_linear(scale)
17
- # CArray#index_log10(scale)
18
- #
19
- # ImageMap.create_image_map_linear(idx, n, palette, mask_color)
20
- # ImageMap.create_image_map_log10(idx, n, palette, mask_color)
21
- #
22
-
23
- class ImageMap < CArray
24
-
25
- def line (x0, y0, x1, y1, z)
26
- x0 = (x0 - @xoffset)*@xscale
27
- y0 = (y0 - @yoffset)*@yscale
28
- x1 = (x1 - @xoffset)*@xscale
29
- y1 = (y1 - @yoffset)*@yscale
30
- draw_line(y0, x0, y1, x1, z)
31
- end
32
-
33
- def polyline (x, y, z)
34
- x = (x - @xoffset).mul!(@xscale)
35
- y = (y - @xoffset).mul!(@xscale)
36
- draw_polyline(y, x, z)
37
- end
38
-
39
- def map_points (pw, pu, pv)
40
- lines, pixels = pw.dim0, pw.dim1
41
- gx = CArray.float(lines, pixels)
42
- gy = CArray.float(lines, pixels)
43
- yield(pu,pv,gx,gy)
44
- gx.sub!(@xoffset).mul!(@xscale)
45
- gy.sub!(@yoffset).mul!(@yscale)
46
- draw_points(gy, gx, pw)
47
- end
48
-
49
- def warp_image0 (pw, pu, pv)
50
- lines, pixels = pw.dim0, pw.dim1
51
- mu = CArray.float(lines, pixels+1)
52
- mv = CArray.float(lines, pixels+1)
53
- gu = CArray.float(lines+1, pixels+1)
54
- gv = CArray.float(lines+1, pixels+1)
55
- gx = CArray.float(lines+1, pixels+1)
56
- gy = CArray.float(lines+1, pixels+1)
57
- CArray.attach(pu,pv,pw) {
58
- [[pu,mu,gu], [pv,mv,gv]].each do |p,m,g|
59
- m[nil,1..-2] = 0.5*p[nil,0..-2] + 0.5*p[nil,1..-1]
60
- m[nil,0] = 1.5*p[nil,0] - 0.5*p[nil,1]
61
- m[nil,-1] = -0.5*p[nil,-2] + 1.5*p[nil,-1]
62
- g[1..-2,nil] = 0.5*m[0..-2,nil] + 0.5*m[1..-1,nil]
63
- g[ 0,nil] = 1.5*m[0,nil] - 0.5*m[1,nil]
64
- g[-1,nil] = -0.5*m[-2,nil] + 1.5*m[-1,nil]
65
- end
66
- yield(gu,gv,gx,gy)
67
- gx.sub!(@xoffset).mul!(@xscale)
68
- gy.sub!(@yoffset).mul!(@yscale)
69
- fill_rectangle_image(gy, gx, pw)
70
- }
71
- end
72
-
73
- def warp_image1 (pw, pu, pv)
74
- lines, pixels = pw.dim0, pw.dim1
75
- px = CArray.float(lines, pixels)
76
- py = CArray.float(lines, pixels)
77
- mx = CArray.float(lines, pixels+1)
78
- my = CArray.float(lines, pixels+1)
79
- gx = CArray.float(lines+1, pixels+1)
80
- gy = CArray.float(lines+1, pixels+1)
81
- CArray.attach(pu,pv,pw) {
82
- yield(pu,pv,px,py)
83
- px.sub!(@xoffset).mul!(@xscale)
84
- py.sub!(@yoffset).mul!(@yscale)
85
- [[px,mx,gx], [py,my,gy]].each do |p,m,g|
86
- m[nil,1..-2] = 0.5*p[nil,0..-2] + 0.5*p[nil,1..-1]
87
- m[nil,0] = 1.5*p[nil,0] - 0.5*p[nil,1]
88
- m[nil,-1] = -0.5*p[nil,-2] + 1.5*p[nil,-1]
89
- g[1..-2,nil] = 0.5*m[0..-2,nil] + 0.5*m[1..-1,nil]
90
- g[ 0,nil] = 1.5*m[0,nil] - 0.5*m[1,nil]
91
- g[-1,nil] = -0.5*m[-2,nil] + 1.5*m[-1,nil]
92
- end
93
- fill_rectangle_image(gy, gx, pw)
94
- }
95
- end
96
-
97
- def warp_grid (pw, pu, pv)
98
- lines, pixels = pw.dim0, pw.dim1
99
- gx = CArray.float(lines, pixels)
100
- gy = CArray.float(lines, pixels)
101
- CArray.attach(pu,pv,pw) {
102
- yield(pu,pv,gx,gy)
103
- gx.sub!(@xoffset).mul!(@xscale)
104
- gy.sub!(@yoffset).mul!(@yscale)
105
- fill_rectangle_grid(gy, gx, pw)
106
- }
107
- end
108
-
109
- def warp_image_gradation (pw, pu, pv)
110
- lines, pixels = pw.dim0, pw.dim1
111
- mu = CArray.float(lines, pixels+1)
112
- mv = CArray.float(lines, pixels+1)
113
- mw = CArray.float(lines, pixels+1)
114
- gu = CArray.float(lines+1, pixels+1)
115
- gv = CArray.float(lines+1, pixels+1)
116
- gw = CArray.float(lines+1, pixels+1)
117
- gx = CArray.float(lines+1, pixels+1)
118
- gy = CArray.float(lines+1, pixels+1)
119
- # bgx = gx[[0,2],[0,2]]
120
- # bgy = gy[[0,2],[0,2]]
121
- # bgw = gw[[0,2],[0,2]]
122
- # p("hello")
123
- CArray.attach(pu,pv,pw) {
124
- [[pu,mu,gu], [pv,mv,gv], [pw.float32,mw,gw]].each do |p,m,g|
125
- m[nil,1..-2] = 0.5*p[nil,0..-2] + 0.5*p[nil,1..-1]
126
- m[nil,0] = 1.5*p[nil,0] - 0.5*p[nil,1]
127
- m[nil,-1] = -0.5*p[nil,-2] + 1.5*p[nil,-1]
128
- g[1..-2,nil] = 0.5*m[0..-2,nil] + 0.5*m[1..-1,nil]
129
- g[ 0,nil] = 1.5*m[0,nil] - 0.5*m[1,nil]
130
- g[-1,nil] = -0.5*m[-2,nil] + 1.5*m[-1,nil]
131
- end
132
- yield(gu,gv,gx,gy)
133
- gx.sub!(@xoffset).mul!(@xscale)
134
- gy.sub!(@yoffset).mul!(@yscale)
135
- draw_rectangle_gradation_grid(gy, gx, gw)
136
- # pw.each_index do |i,j|
137
- # draw_rectangle_gradation(bgy.move(i,j), bgx.move(i,j), bgw.move(i,j))
138
- # end
139
- }
140
- end
141
-
142
- def warp_grid_gradation (pw, pu, pv)
143
- lines, pixels = pu.dim0, pv.dim1
144
- gx = CArray.float(lines, pixels)
145
- gy = CArray.float(lines, pixels)
146
- CArray.attach(pu,pv,pw) {
147
- yield(pu,pv,gx,gy)
148
- gx.sub!(@xoffset).mul!(@xscale)
149
- gy.sub!(@yoffset).mul!(@yscale)
150
- # bx = gx[[0,2],[0,2]]
151
- # by = gy[[0,2],[0,2]]
152
- # bw = pw[[0,2],[0,2]]
153
- draw_rectangle_gradation_grid(gy, gx, pw)
154
- # pw[0..-2,0..-2].each_index do |i,j|
155
- # draw_rectangle_gradation(by.move(i,j), bx.move(i,j), bw.move(i,j))
156
- # end
157
- }
158
- end
159
-
160
- def warp_grid_interpolation (pw, pu, pv, n, &block)
161
- lines, pixels = pu.dim0, pv.dim1
162
- m = 2+n
163
- hu = CArray.float(m, m)
164
- hv = CArray.float(m, m)
165
- hw = CArray.float(m, m)
166
- bu = pu[[0,2],[0,2]]
167
- bv = pv[[0,2],[0,2]]
168
- bw = pw[[0,2],[0,2]]
169
- CArray.attach(pu,pv,pw) {
170
- pw[0..-2,0..-2].each_index do |i,j|
171
- bu.move(i,j)
172
- bv.move(i,j)
173
- bw.move(i,j)
174
- hu.grid_new([[0,m-1],[0,m-1]])[] = bu
175
- hv.grid_new([[0,m-1],[0,m-1]])[] = bv
176
- hw.grid_new([[0,m-1],[0,m-1]])[] = bw
177
- [hu, hv, hw].each do |h|
178
- h[nil, 0].span!(h[0,0]..h[m-1,0])
179
- h[nil, m-1].span!(h[0,m-1]..h[m-1,m-1])
180
- h.dim0.times do |i|
181
- h[i, nil].span!(h[i,0]..h[i,m-1])
182
- end
183
- end
184
- warp_grid_gradation(hw, hu, hv, &block)
185
- end
186
- }
187
- end
188
-
189
- def initialize (*argv)
190
- super
191
- @yscale = 1
192
- @xscale = 1
193
- @yoffset = 0
194
- @xoffset = 0
195
- end
196
-
197
- attr_accessor :yscale, :xscale, :yoffset, :xoffset
198
-
199
- def set_xrange (rng)
200
- first = rng.begin
201
- last = rng.end
202
- if rng.exclude_end?
203
- @xscale = (dim1-1).to_f/(last-first).to_f
204
- else
205
- @xscale = dim1.to_f/(last-first).to_f
206
- end
207
- @xoffset = first
208
- end
209
-
210
- def set_yrange (rng)
211
- first = rng.begin
212
- last = rng.end
213
- if rng.exclude_end?
214
- @yscale = (dim0-1).to_f/(first-last).to_f
215
- @yoffset = last - @yscale
216
- else
217
- @yscale = dim0.to_f/(first-last).to_f
218
- @yoffset = last
219
- end
220
- end
221
-
222
- def warp (data, x, y, opt = {}, &block)
223
- option = {
224
- :grid => "point",
225
- :interpolation => nil,
226
- :gradation => false,
227
- }
228
- option.update(opt)
229
- case option[:grid]
230
- when /^area([01]|)$/, "pixel"
231
- if option[:interpolation]
232
- raise("can't interpolate in pixel mode")
233
- else
234
- if option[:gradation]
235
- warp_image_gradation(data, x, y, &block)
236
- else
237
- if option[:grid] == "area" or option[:grid] == "area0"
238
- warp_image0(data, x, y, &block) ### inter(extra)polation before
239
- else
240
- warp_image1(data, x, y, &block) ### inter(extra)polation after
241
- end
242
- end
243
- end
244
- when "point"
245
- if option[:interpolation]
246
- warp_grid_interpolation(data, x, y, option[:interpolation], &block)
247
- else
248
- if option[:gradation]
249
- warp_grid_gradation(data, x, y, &block)
250
- else
251
- warp_grid(data, x, y, &block)
252
- end
253
- end
254
- else
255
- raise("unknown grid type")
256
- end
257
- end
258
-
259
- def tfw (metric = 1.0)
260
- format([["%f"]*6].join("\n"),
261
- metric/@xscale,
262
- 0,
263
- 0,
264
- metric/@yscale,
265
- metric*(@xoffset+0.5/@xscale),
266
- metric*(@yoffset+0.5/@yscale))
267
- end
268
-
269
- end
270
-
271
- require 'carray/carray_imagemap.so'
272
-
273
-
@@ -1,4 +0,0 @@
1
- require 'carray/graphics/imagemap'
2
-
3
- warn "carray/image_map.rb will be obsolete"
4
-
@@ -1,83 +0,0 @@
1
- require 'carray'
2
- require 'carray/image_map'
3
- require 'sdi/hdf'
4
- require 'proj4'
5
-
6
- RESOLUTION = 5 # (km) on map projection
7
- UL_CORNER = [3000, 0] # (km) on map projection
8
- LR_CORNER = [0, 3000] # (km) on map projection
9
- SCANLINES = 2
10
-
11
- PROJECTION = "+proj=stere +lat_0=-90 +units=km"
12
-
13
- IMAGE_HEIGHT = (UL_CORNER[0] - LR_CORNER[0])/RESOLUTION.to_f + 1
14
- IMAGE_WIDTH = (LR_CORNER[1] - UL_CORNER[1])/RESOLUTION.to_f + 1
15
-
16
- SCALE_Y = -(UL_CORNER[0] - LR_CORNER[0])/(IMAGE_HEIGHT.to_f - 1)
17
- SCALE_X = (LR_CORNER[1] - UL_CORNER[1])/(IMAGE_WIDTH.to_f - 1)
18
- OFFSET_Y = UL_CORNER[0].to_f # LOWERRIGHT[0].to_f
19
- OFFSET_X = UL_CORNER[1].to_f
20
-
21
- image = ImageMap::Image.new(CA_INT32, [IMAGE_HEIGHT, IMAGE_WIDTH]) { -9999 }
22
- image.set_xrange(UL_CORNER[1]..LR_CORNER[1])
23
- image.set_yrange(LR_CORNER[0]..UL_CORNER[0])
24
-
25
- #
26
- #
27
- #
28
-
29
- sdi = SDI::HDF.open(ARGV[0])
30
- clat = sdi.open("Latitude")[]
31
- clon = sdi.open("Longitude")[]
32
- height = sdi.open("SolarZenith")[]
33
- sdi.close
34
-
35
- NSCANS = clat.dim0/SCANLINES
36
- NPIXELS = clat.dim1
37
-
38
- #cidx = clat.index
39
- #cidx = clat.template.random!(1000)
40
- cidx = height.copy
41
-
42
- proj = Proj4.new(PROJECTION)
43
-
44
- (NSCANS).times do |ns|
45
-
46
- printf("%i/%i\n", ns, NSCANS)
47
-
48
- line = ns * SCANLINES
49
-
50
- bidx = cidx[[line, SCANLINES], nil].copy
51
- blat = clat[[line, SCANLINES], nil].copy
52
- blon = clon[[line, SCANLINES], nil].copy
53
-
54
- image.warp(bidx, blon, blat, :grid => "area", :gradation => false) {
55
- # image.map_points(bidx, blon, blat) {
56
- |lo,la,gx,gy|
57
- proj.fwd_f(lo, la, gx, gy)
58
- }
59
-
60
- end
61
-
62
- puts "projection done"
63
-
64
- #image = height.map_object(image, -9999)
65
- image.mask = image < -9998
66
-
67
- puts "masking flipping done"
68
-
69
- sc = nil
70
- #sc = ImageMap::ColorScale.GMT("GMT_globe.cpt")
71
- #sc = ImageMap::ColorScale.GMT("DEM_poster.cpt")
72
-
73
- ImageMap.display(image, sc)
74
-
75
- open("projection.tfw", "w") { |io|
76
- io.printf([["%g\n"]*6].join(),
77
- RESOLUTION*1000,
78
- 0,
79
- 0,
80
- -RESOLUTION*1000,
81
- OFFSET_X*1000+RESOLUTION*500,
82
- OFFSET_Y*1000+RESOLUTION*500)
83
- }
@@ -1,99 +0,0 @@
1
- require 'carray'
2
- require 'carray/image_map'
3
- require 'sdi/hdf'
4
- require 'proj4'
5
- require 'benchmark'
6
-
7
- RESOLUTION = 10 # (km) on map projection
8
- UL_CORNER = [3000, -3000] # (km) on map projection
9
- LR_CORNER = [-3000, 3000] # (km) on map projection
10
- SCANLINES = 2
11
-
12
- PROJECTION = "+proj=stere +lat_0=-90 +units=km"
13
-
14
- IMAGE_HEIGHT = (UL_CORNER[0] - LR_CORNER[0])/RESOLUTION.to_f + 1
15
- IMAGE_WIDTH = (LR_CORNER[1] - UL_CORNER[1])/RESOLUTION.to_f + 1
16
-
17
- SCALE_Y = -(UL_CORNER[0] - LR_CORNER[0])/(IMAGE_HEIGHT.to_f - 1)
18
- SCALE_X = (LR_CORNER[1] - UL_CORNER[1])/(IMAGE_WIDTH.to_f - 1)
19
- OFFSET_Y = UL_CORNER[0].to_f # LOWERRIGHT[0].to_f
20
- OFFSET_X = UL_CORNER[1].to_f
21
-
22
- image = ImageMap.new(CA_INT32, [IMAGE_HEIGHT, IMAGE_WIDTH]) { -9999 }
23
- image.set_xrange(UL_CORNER[1]..LR_CORNER[1])
24
- image.set_yrange(LR_CORNER[0]..UL_CORNER[0])
25
-
26
- #
27
- #
28
- #
29
-
30
- sdi = SDI::HDF.open(ARGV[0])
31
- clat = sdi.open("Latitude")[]
32
- clon = sdi.open("Longitude")[]
33
- height = sdi.open("Height")[]
34
- sdi.close
35
-
36
- NSCANS = clat.dim0/SCANLINES
37
- NPIXELS = clat.dim1
38
-
39
- #cidx = clat.index
40
- #cidx = clat.template.random!(1000)
41
- cidx = height.copy
42
-
43
- proj = Proj4.new(PROJECTION)
44
-
45
- Benchmark.bm do |rep|
46
- rep.report do
47
- (NSCANS).times do |ns|
48
-
49
- # printf("%i/%i\n", ns, NSCANS)
50
-
51
- line = ns * SCANLINES
52
-
53
- bidx = cidx[[line, SCANLINES], nil].copy
54
- blat = clat[[line, SCANLINES], nil].copy
55
- blon = clon[[line, SCANLINES], nil].copy
56
-
57
- image.warp(bidx, blon, blat, :grid => "area", :gradation => false) {
58
- # image.map_points(bidx, blon, blat) {
59
- |lo,la,gx,gy|
60
- proj.fwd_f(lo, la, gx, gy)
61
- }
62
-
63
- end
64
- end
65
- end
66
-
67
- puts "projection done"
68
-
69
- #image = height.map_object(image, -9999)
70
- image.mask = image < -9998
71
-
72
- puts "masking flipping done"
73
-
74
- #sc = nil
75
- sc = ColorScale.GMT("GMT_topo.cpt")
76
- #sc = ImageMap::ColorScale.GMT("DEM_poster.cpt")
77
-
78
- #colors = CArray.float(5,5)
79
- #colors[0,nil] = [0, 0, 0, 0, 1]
80
- #colors[1,nil] = [1990, 0, 0, 0, 1]
81
- #colors[2,nil] = [2000, 1, 1, 1, 0]
82
- #colors[3,nil] = [2010, 0, 0, 0, 1]
83
- #colors[4,nil] = [5000, 0, 0, 0, 1]
84
- #sc = ImageMap::ColorScale.mapping(colors)
85
- #p sc.scale
86
- #p sc.palette
87
-
88
- ImageMap.display(image, sc)
89
-
90
- open("projection.tfw", "w") { |io|
91
- io.printf([["%g\n"]*6].join(),
92
- RESOLUTION*1000,
93
- 0,
94
- 0,
95
- -RESOLUTION*1000,
96
- OFFSET_X*1000+RESOLUTION*500,
97
- OFFSET_Y*1000+RESOLUTION*500)
98
- }
99
-