MeteoThink

http://meteothink.org/docs/
Admin
MeteoThink is a comprehensive meteorological data analysis and visualization platform featuring...
Tokens:174,535
Snippets:1,300
Trust Score:3.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Configure JVM Memory Allocation

Source: http://meteothink.org/docs/introduction.html

Example of starting a Java Virtual Machine (JVM) with specific initial and maximum memory allocations. Adjust Xmx in starting files to resolve OutOfMemoryError.

```bash
java -Xmx1G -Xms128m
```

--------------------------------

### Create and Display a Plot

Source: http://meteothink.org/docs/meteoinfolab/userguide/gui.html

Example of creating a list and then plotting it using the 'plot' command.

```python
>>> a = [1,2,3,4]
>>> plot(a)
```

--------------------------------

### 3D Streamline Plot with Start Positions

Source: http://meteothink.org/docs/meteoinfolab/plot/axes3dgl/streamplot3.html

Creates a 3D streamline plot with specified starting points for the streamlines. This example demonstrates how to use the 'start_x', 'start_y', and 'start_z' parameters, along with 'interval' for controlling streamline generation. Requires scatter3, colorbar, and lighting functions.

```python
# Make the grid
x, y, z = meshgrid(arange(-1.5, 1.5, 0.1),
                   arange(-1.5, 1.5, 0.1),
                   arange(-1.5, 1.5, 0.1))

# Make the direction data for the arrows
u = x + cos(4*x) + 3         # x-component of vector field
v = sin(4*x) - sin(2*y)      # y-component of vector field
w = -z                       # z-component of vector field
speed = sqrt(u*u + v*v + w*w)

sx, sy, sz = meshgrid([-1.5], [-1,0,1], [-1,0,1])

qq = streamplot3(x, y, z, u, v, w, speed, linewidth=2,
    density=4, interval=10, start_x=sx, start_y=sy, start_z=sz)
scatter3(sx, sy, sz, c='k')
colorbar(qq)
xlim(-1.5, 1.5)
ylim(-1.5, 1.5)
zlim(-1.5, 1.5)
antialias(True)

```

--------------------------------

### Image Flip Example

Source: http://meteothink.org/docs/meteoinfolab/imagelib/filter/flip.html

Demonstrates how to read an image, display it, flip it horizontally, and display the flipped image. Ensure the image file path is correct.

```python
fn = 'D:/Temp/image/Lenna.png'
lena = imagelib.imread(fn)
subplot(1, 2, 1,aspect='equal', tickline=False)
imshow(lena)
subplot(1, 2, 2, aspect='equal', tickline=False)
lena_1 = imagelib.flip(lena)
imshow(lena_1)

```

--------------------------------

### Plotting Trajectory on Map with plotm

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/plotm.html

This example demonstrates how to plot a flight path trajectory on a map using the plotm function. It involves loading geographical data, setting up map axes, displaying country boundaries, plotting the trajectory line, and marking the starting point.

```python
f = addfile('D:/Temp/hdf/2010128055614_21420_CS_2B-GEOPROF_GRANULE_P_R04_E03.hdf')
lon = f['Longitude'][:]
lat = f['Latitude'][:]
axesm()
lworld = shaperead('D:/Temp/map/country1.shp')
geoshow(lworld, edgecolor='k')
plotm(lon, lat, '-b', linewidth=4)
scatterm(lon[0], lat[0], size=6, facecolor='r')
xlim(-180, 180)
ylim(-90, 90)
title('Trajectory of Flight Path (starting point in red)')
```

--------------------------------

### Plotting with Grid

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/grid.html

This example demonstrates how to plot a function and then enable the default major grids on both axes. Ensure 'arange', 'plot' are imported.

```python
x = arange(0., 5., 0.2)
y = x**2
plot(x, y, label='Series_1', linewidth=2.0)
plot(x, y, 'bo')
grid()
```

--------------------------------

### Semilogy Plot Example

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/semilogy.html

This example demonstrates how to create a semilogy plot with custom styling, grid, labels, and axis limits. Ensure necessary imports like arange and exp are available.

```python
x = arange(0, 20.1, 1.0)
y = exp(-x/5.0)
semilogy(x, y, 'r-o')
grid(True)
ylabel('Y Axis')
xlabel('X Axis')
legend()
xlim(0,20)
set(plt.gca, xminortick=True, yminortick=True)
title('Semilogy')
```

--------------------------------

### Polynomial Fitting Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/fitting/polyfit.html

Demonstrates how to use polyfit to fit a polynomial to data points and then plot the original data along with the fitted curve using polyval.

```python
from mipylib.numeric import fitting

x = linspace(0, 4*pi, 10)
y = sin(x)

#Plot data points
plot(x, y, 'ro', fill=False, size=1)

#Use polyfit to fit a 7th-degree polynomial to the points
r = fitting.polyfit(x, y, 7)

#Plot fitting line
xx = linspace(0, 4*pi, 100)
p = r[0]
yy = fitting.polyval(p, xx)
plot(xx, yy, '-b')
title('Polynomial fitting example')
```

--------------------------------

### Bilinear Interpolation Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/interpolate/linint2.html

Demonstrates how to use linint2 to interpolate pressure data from a model grid to a new grid. Includes plotting the original and interpolated data.

```python
fn = os.path.join(migl.get_sample_folder(), 'GrADS', 'model.ctl')
f = addfile(fn)
ps = f['PS'][:,'10:60','60:140']
lon = arange(50, 142, 2.5)
lat = arange(5, 66, 2.5)
nps = interpolate.linint2(ps, lon, lat)

levs = arange(500, 1021, 20)

#Plot
subplot(2,1,1,axestype='map')
geoshow('country', edgecolor=(0,0,255))
layer = imshow(lon, lat, nps[1,:,:], levs)
title('Pressure - linint2')
colorbar(layer)

subplot(2,1,2,axestype='map')
geoshow('country', edgecolor=(0,0,255))
layer = imshow(ps[1,:,:], levs)
title('Pressure - origin')
colorbar(layer)
```

--------------------------------

### Linear Regression Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/stats/linregress.html

Demonstrates how to perform a linear regression on a dataset, plot the original data and the fitted line, and display the regression equation and R-squared value.

```python
fn = 'D:/Temp/ascii/skincancer.txt'
table = readtable(fn, format='%s%f%2i%f')
lat = table['Lat']
mort = table['Mort']

slope, intercept, r_value, p_value, std_err = stats.linregress(lat, mort)
scatter(lat, mort, label='original data', edge=False)
plot(lat, intercept + slope*lat, 'r', label='fitted line')
text(29, 100, r'$\hat{{y}} = ' + '%.2f' % slope + 'x + ' + 
    '%.1f' % intercept + '$', fontsize=16)
text(29, 88, r'$R^2 = '+ '%.4f' % (r_value**2) + '$', fontsize=16)
legend()
xlim(27, 50)
ylim(75, 250)
xticks(arange(30, 51, 5))
yticks(arange(100, 226, 25))
title('Skin Cancer Mortality versus State Latitude')
xlabel('Latitude (at center of state)')
ylabel('Mortality (Deaths per 10 million)')

```

--------------------------------

### Display Image Data on Map with imshowm

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/imshowm.html

This example demonstrates how to load satellite data, plot it on a map with geographical context, and display a colorbar. Ensure the necessary data files and shapefiles are accessible.

```python
#Add data file
folder = 'D:/Temp/hdf/'ns = 'OMI-Aura_L3-OMTO3e_2005m1214_v002-2006m0929t143855.he5'
fn = folder + fns
f = addfile(fn)
vname = 'ColumnAmountO3'
v = f[vname]
data = v[:,:]
#Plot
axesm()
mlayer = shaperead('D:/Temp/map/country1.shp')
geoshow(mlayer, edgecolor='k')
layer = imshowm(data, 20)
colorbar(layer)
title('OMI - ' + vname)
axism()

```

--------------------------------

### Read and Display Geospatial Data

Source: http://meteothink.org/docs/meteoinfolab/geolib/migeo/georead.html

Demonstrates reading a JPG image and a shapefile, then displaying them on a map. Requires prior setup with addfile and specific data paths.

```python
f = addfile('D:/Temp/GrADS/model.ctl')
ps = f['PS'][0,[10,60],[70,140]]
lrelief = georead('D:/Temp/Map/GLOBALeb3colshade.jpg')
world = georead('D:/Temp/Map/country1.shp')
axesm()
geoshow(lrelief)
geoshow(world, edgecolor=[0,0,255])
cols = makecolors(20, alpha=128)
layer = contourfm(ps, colors=cols, edgecolor='gray', order=1)
title('Pressure')
colorbar(layer, aspect=12)
```

--------------------------------

### Image Emboss Example

Source: http://meteothink.org/docs/meteoinfolab/imagelib/filter/emboss.html

Applies the emboss filter to an image and displays the original and embossed versions side-by-side. Ensure the image file path is correct.

```python
fn = 'D:/Temp/image/Lenna.png'
lena = imagelib.imread(fn)
subplot(1, 2, 1,aspect='equal', tickline=False)
imshow(lena)
subplot(1, 2, 2, aspect='equal', tickline=False)
lena_1 = imagelib.emboss(lena)
imshow(lena_1)

```

--------------------------------

### Least-Squares Solution Result

Source: http://meteothink.org/docs/meteoinfolab/numeric/linalg/lstsq.html

This shows the output array of coefficients obtained from the least-squares fit in the previous example.

```python
>>> run script...
array([3.0, 2.23606797749979, 2.0, 0.0])
```

--------------------------------

### Compute Least-Squares Solution and Plot Fit

Source: http://meteothink.org/docs/meteoinfolab/numeric/linalg/lstsq.html

This example demonstrates how to use `linalg.lstsq` to find the coefficients of a quadratic fit to data points. It then plots the original data and the fitted curve.

```python
x = array([1, 2.5, 3.5, 4, 5, 7, 8.5])
y = array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])
M = ones((len(x),2))
M[:,1] = x**2
p, res = linalg.lstsq(M, y)
print p

#Plot
plot(x, y, 'bo', label='data')
xx = linspace(0, 9, 101)
yy = p[0] + p[1]*xx**2
plot(xx, yy, label='least squares fit, $y = a + bx^2$')
xlabel('x')
ylabel('y')
legend(loc='upper left')
grid(alpha=0.25)
```

--------------------------------

### Basic Boxplot Example

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/boxplot.html

Generates a boxplot from random data. Ensure 'random' is imported and 'title' function is available for plot customization.

```python
import random

data = []
for i in range(6):
    data.append(random.randn(500))
boxplot(data)
title('Box plot demo')
```

--------------------------------

### 3D imshow Example

Source: http://meteothink.org/docs/meteoinfolab/plot/axes3dgl/imshow.html

Demonstrates how to use Axes3DGL.imshow to plot multiple 2D slices of an image on a 3D plot. Requires data loading and preparation using meteolib and addfile.

```python
fn = 'D:/Temp/nc/air_clm.nc'
f = addfile(fn)
ps_x = f['aveair'][0,:,:,'120']
pres = ps_x.dimvalue(0)
z = meteolib.pressure_to_height_std(pres)
ps_x.setdimvalue(0, z)
ps_y = f['aveair'][0,:,'20','0:180']
ps_y.setdimvalue(0, z)
ps_z = f['aveair'][0,5,:,'0:180']

#Plot
ax = axes3d()
geoshow('continent', color='c', edgecolor='b')
levs = arange(200, 300, 10)
ls = imshow(ps_x, levs, offset=120, zdir='x', alpha=0.8)
imshow(ps_y, levs, offset=20, zdir='y', alpha=0.8)
imshow(ps_z, levs, offset=z[5], zdir='z', alpha=0.8)
colorbar(ls)
zlim(0, z[-1])
xlim(0, 180)
xlabel('Longitude')
ylabel('Latitude')
title('3D imshow example')
```

--------------------------------

### Image Invert Example

Source: http://meteothink.org/docs/meteoinfolab/imagelib/filter/invert.html

Demonstrates how to use the invert filter to invert the RGB channels of an image. Requires an image file path and uses subplot for displaying original and inverted images.

```python
fn = 'D:/Temp/image/Lenna.png'
lena = imagelib.imread(fn)
subplot(1, 2, 1,aspect='equal', tickline=False)
imshow(lena)
subplot(1, 2, 2, aspect='equal', tickline=False)
lena_1 = imagelib.invert(lena)
imshow(lena_1)

```

--------------------------------

### NearestNDInterpolator Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/interpolate/NearestNDInterpolator.html

Demonstrates nearest-neighbor interpolation in 3D. It defines a function, generates random data, creates an interpolator, interpolates over a grid, and visualizes the results using scatter plots.

```python
def func(x,y,z):
    return 0.5*(3)**(1./2)-((x-0.5)**2+(y-0.5)**2+(z-0.5)**2)**(1./2)

x = random.rand(1000)
y = random.rand(1000)
z = random.rand(1000)
v = func(x,y,z)

f = interpolate.NearestNDInterpolator([x,y,z], v)

gx = linspace(x.min(), x.max(), 50)
gy = linspace(y.min(), y.max(), 50)
gz = linspace(z.min(), z.max(), 50)
xx,yy,zz = meshgrid(gx, gy, gz)
gv = f([xx,yy,zz])

levs = arange(0.1, 1.1, 0.1)
scatter3(x, y, z, c=v, levels=levs)
scatter3(xx, yy, zz, c=gv, s=2, levels=levs, alpha=0.5)
colorbar()
```

--------------------------------

### Cholesky Decomposition Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/linalg/cholesky.html

Demonstrates how to compute the Cholesky decomposition of a 3x3 and a 4x4 matrix using `np.linalg.cholesky`. The input matrix must be Hermitian (symmetric if real-valued) and positive-definite.

```python
a1 = array([[25,15,-5],[15,18,0],[-5,0,11]])
r1 = np.linalg.cholesky(a1)
print r1

a2 = array([[18,22,54,42],[22,70,86,62],[54,86,174,134],[42,62,134,106]])
r2 = np.linalg.cholesky(a2)
print r2
```

--------------------------------

### Fill Between Example

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/fill_between.html

Demonstrates filling areas between curves using fill_between with conditional logic. Requires numpy and matplotlib for linspace, sin, plot, xlim, ylim, and title.

```python
n = 256
X = linspace(-pi,pi,n,endpoint=True)
Y = sin(2*X)

fill_between(X, 1, Y+1, color='blue', alpha=.25)
plot(X, Y+1, color='blue')

fill_between(X, -1, Y-1, (Y-1) > -1, color='blue', alpha=.25)
fill_between(X, -1, Y-1, (Y-1) < -1, color='red',  alpha=.25)
plot(X, Y-1, color='blue')
xlim(-pi, pi)
ylim(-2.5, 2.5)
title('fill_between example')
```

--------------------------------

### Kriging Interpolation Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/interpolate/griddata.html

Illustrates Kriging interpolation for precipitation data across China. It preprocesses scattered data, interpolates it to a grid, and visualizes the results with national and provincial boundaries, cities, and a legend.

```python
fn = os.path.join(migl.get_sample_folder(), 'MICAPS', '10101414.000')
f = addfile_micaps(fn)
pr = f['Precipitation6h'][:]
lon = f['Longitude'][:]
lat = f['Latitude'][:]

mask_rect = geolib.polygon([72,72,136,136], [16,55,55,16])
pr,lon,lat = geolib.rmaskout(pr, lon, lat, mask_rect)
idx = where(pr != nan)
pr = pr[idx]
lon = lon[idx]
lat = lat[idx]

#griddata function - interpolate
x = arange(75, 135, 0.5)
y = arange(18, 55, 0.5)
prg = griddata((lon, lat), pr, xi=(x, y), method='kriging')[0]

#Plot
figure(figsize=[700,550], newfig=False)
proj = projinfo(proj='lcc', lon_0=105, lat_1=25, lat_2=47)
axesm(projinfo=proj, position=[0.01, 0.01, 0.99, 0.99], axison=False, gridlabel=False, frameon=False)
geoshow('cn_province', edgecolor='lightgray')
bou1_layer = geoshow('cn_border', facecolor=(0,0,255))
city_layer = geoshow('cn_cities', facecolor='r', size=4)
city_layer.addlabels('NAME', fontname=u'楷体', fontsize=16, yoffset=15, avoidcoll=False)
china_layer = geoshow('china', visible=False)
city_layer.movelabel(u'西宁', -15)
city_layer.movelabel(u'海口', -20, -10)
city_layer.movelabel(u'澳门', 0, -25)
city_layer.movelabel(u'香港', 20, -10)
city_layer.movelabel(u'福州', -10)
city_layer.movelabel(u'合肥', -18)
city_layer.movelabel(u'杭州', 0, -20)
city_layer.movelabel(u'上海', 18)
city_layer.movelabel(u'太原', 0, -20)
city_layer.movelabel(u'天津', 15)
city_layer.movelabel(u'石家庄', -10)
levs = [0.1, 1, 2, 5, 10, 20, 25, 50, 100]
cols = [(255,255,255),(170,240,255),(120,230,240),(200,220,50),(240,220,20),(255,120,10),(255,90,10), \
    (240,40,0),(180,10,0),(120,10,0)]
layer = contourf(x, y, prg, levs, colors=cols)
masklayer(china_layer, [layer])
legend(layer, loc='lower left', frameon=True, title=u'降雨量(mm)', titlefontname=u'黑体')
axism([79, 128, 14, 53])
text(95, 53, u'全国降水量实况图', fontname=u'黑体', fontsize=18)
text(95, 51, u'(2010-10-14 08:00 至 2010-10-14 14:00)', fontname=u'黑体', fontsize=16)

#Add south China Sea
sc_layer = bou1_layer.clone()
axesm(position=[0.15,0.05,0.15,0.2], axison=False, frameon=True)
geoshow(sc_layer, facecolor=(0,0,255))
xlim(106, 123)
ylim(2, 23)
```

--------------------------------

### Fill Between X Example

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/fill_betweenx.html

Demonstrates filling polygons between two curves using fill_betweenx. It shows conditional filling based on boolean expressions and sets plot limits and title.

```python
n = 256
y = linspace(-pi, pi, n, endpoint=True)
x = sin(2 * y)

fill_betweenx(y, 1, x+1, color='blue', alpha=.25)
plot(x+1, y, color='blue')

fill_betweenx(y, -1, x-1, (x-1) > -1, color='blue', alpha=.25)
fill_betweenx(y, -1, x-1, (x-1) < -1, color='red',  alpha=.25)
plot(x-1, y, color='blue')
ylim(-pi, pi)
xlim(-2.5, 2.5)
title('fill_betweenx example')
```

--------------------------------

### Display Image with imshow

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/imshow.html

Use imshow to display a 2D array as an image. This example loads data from a file, extracts a 2D array, displays it using imshow, adds a title, and a colorbar.

```python
f = addfile('D:/Temp/nc/cone.nc')
u = f['u'][4,:,:]
layer = imshow(u, 20)
title('Cone amplitude - imshow')
colorbar(layer)
```

--------------------------------

### Get the first N rows of a DataFrame

Source: http://meteothink.org/docs/meteoinfolab/dataframe/dataframe/head.html

Specify the number of rows to retrieve by passing an integer argument to the head() method. This example shows how to get the top 3 rows.

```python
>>> df.head(3)
      animal
0  alligator
1        bee
2     falcon


```

--------------------------------

### Exponent Fitting Example

Source: http://meteothink.org/docs/meteoinfolab/numeric/fitting/expfit.html

Demonstrates how to use expfit for exponential curve fitting and prediction. It generates sample data, performs the fit, predicts a value, and plots the original data along with the fitted curve.

```python
from mipylib.numeric import fitting

x = linspace(0.1, 10, 200)
y = 20*pow(e, 3*x)
plot(x, y, 'ro', fill=False, size=1)
r = np.fitting.expfit(x, y, func=True)
f = r[3]
py = fitting.predict(f, 0.2)
print py
print 20*pow(e, 3*0.2)

#Plot fitting line
xx = linspace(x.min(), x.max(), 100)
yy = r[0]*pow(e, r[1]*xx)
plot(xx, yy, '-b', linewidth=2)
title('Exponent fitting example')
```

--------------------------------

### Get Cross Point of Two Line Segments

Source: http://meteothink.org/docs/wContour_api/wcontour/Contour.html

Calculates the intersection point of two line segments defined by their start and end points. Returns the PointF coordinates of the intersection.

```java
public static PointF getCrossPoint(PointF aP1, PointF aP2, PointF bP1, PointF bP2)
```

--------------------------------

### Read Binary Data and Plot

Source: http://meteothink.org/docs/meteoinfolab/dataset/midata/binread.html

This example demonstrates reading brightness temperature data from a binary file and plotting it. It includes setting up projection information, defining grid parameters, reading the data using binread, performing data transformations, and visualizing the data with a colorbar and map.

```python
#Data source: https://nsidc.org/data/docs/daac/nsidc0032_ssmi_ease_tbs.gd.html
#DMSP SSM/I-SSMIS Pathfinder Daily EASE-Grid Brightness Temperatures, Version 2

fn = 'D:/Temp/binary/ID2-F17-SH2015035D-V2.91V'

#Set projection
proj = projinfo(proj='laea', lat_0=-90, lon_0=0)
xn = 1441             #Column number
yn = 1441             #Row number
dx = 12.5 * 1000      #X resolution (m)
dy = 12.5 * 1000      #Y resolution (m)
x0 = -9000 * 1000 + dx / 2     #Lower left x corner
y0 = -9000 * 1000 + dy / 2    #Lower left y corner
x = arange1(x0, xn, dx)
y = arange1(y0, yn, dy)

#Read data
data = binread(fn, [yn, xn], 'short')
data = data[::-1,:].astype('float')
data = data / 10
data[data==0] = nan   #0 is missing value

#Plot
axesm(projinfo=proj, gridline=True, griddx=30, griddy=30)
lworld = shaperead('D:/Temp/Map/country1.shp')
geoshow(lworld, edgecolor='k')
layer = imshowm(x, y, data, 20, cmap='BlAqGrYeOrRe', proj=proj)
colorbar(layer)
title('Brightness Temperatures')

```

--------------------------------

### Get last N rows of DataFrame

Source: http://meteothink.org/docs/meteoinfolab/dataframe/dataframe/tail.html

Specify the number of rows to retrieve using the 'n' parameter in the tail() method. This example shows retrieving the last 3 rows.

```python
>>> df.tail(3)
      animal
6      shark
7      whale
8      zebra


```

--------------------------------

### Create a DataFrame

Source: http://meteothink.org/docs/meteoinfolab/dataframe/dataframe/head.html

Initialize a DataFrame with sample data. This is a prerequisite for using the head() method.

```python
>>> df = DataFrame({'animal':['alligator', 'bee', 'falcon', 'lion',
...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
      animal
0  alligator
1        bee
2     falcon
3       lion
4     monkey
5     parrot
6      shark
7      whale
8      zebra


```

--------------------------------

### Plotting a wind field with quiverm

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/quiverm.html

This example demonstrates how to load data, calculate wind speed, and then plot a wind field using quiverm. It also shows how to add a quiver key for scale, a colorbar, a title, and set y-axis ticks.

```python
f = addfile('D:/Temp/GrADS/model.ctl')
u = f['U'][0,'500','10:60','60:140']
v = f['V'][0,'500','10:60','60:140']
speed = sqrt(u*u+v*v)
#Plot
axesm()
lworld = shaperead('D:/Temp/Map/country1.shp')
geoshow(lworld)
layer = quiverm(u, v, speed, 10, size=8)
quiverkey(layer, 0.74, 0.18, 15, bbox={'edge':True, 'fill':True})
colorbar(layer)
title('Wind field')
yticks([20,40,60])
```

--------------------------------

### 3D Map Lines and Trajectories Plot

Source: http://meteothink.org/docs/meteoinfolab/plot/axes3dgl/plot3.html

Plots 3D trajectories with varying colors based on a scalar field (RH) and adds markers for start and end points. It also overlays geographical data like provinces and countries with elevation coloring. Requires extensive setup for data loading, interpolation, and map layers.

```python
fn = 'D:/Temp/HYSPLIT/500_previous'

f = addfile_hytraj(fn)
lon = f['lon'][:,:]
lat = f['lat'][:,:]
alt = f['height'][:,:]
rh = f['RELHUMID'][:,:]

#Relief data
rfn = 'D:/Temp/nc/elev.0.25-deg.nc'
rf = addfile(rfn)
elev = rf['data'][0,'15:65','65:155']
elev[elev<0] = -1
lon1 = elev.dimvalue(1)
lat1 = elev.dimvalue(0)
lon1, lat1 = meshgrid(lon1, lat1)

#Map
lchina = shaperead('cn_province')
clon = lchina.x_coord
clat = lchina.y_coord
calt = zeros(len(clon))
h = interp2d(elev, clon, clat)
calt = calt + h
lworld = shaperead('country')
wlon = lworld.x_coord
wlat = lworld.y_coord
walt = zeros(len(wlon))
h = interp2d(elev, wlon, wlat)
walt = walt + h

#Plot
ax = axes3d()
ax.set_elevation(-60)
ax.set_rotation(341)
levs = arange(0, 6000, 200)
cols = makecolors(len(levs) + 1, cmap='SVG_bhw3_22')
cols[0] = [51,153,255]
surf(lon1, lat1, elev, levs, colors=cols,
    facecolor='interp', edgecolor=None, lighting=False)
plot3(clon, clat, calt, color=[255,153,255])
plot3(wlon, wlat, walt, color='c')
levs1 = arange(10, 99, 5)
traj = plot3(lon, lat, alt, mvalues=rh, levels=levs1, linewidth=2)
scatter3(lon[:,0], lat[:,0], alt[:,0], size=6, c='k')
scatter3(lon[:,-1], lat[:,-1], alt[:,-1], size=6, c='r')
colorbar(traj, aspect=30, label='RH (%)')
xlim(100, 130)
xlabel('Longitude')
vim(25, 50)
ylabel('Latitude')
zlim(0, 14000)
zlabel('Height (m)')

```

--------------------------------

### logspace Function

Source: http://meteothink.org/docs/meteoinfolab/numeric/functions/logspace.html

Generates numbers spaced evenly on a log scale. The sequence starts at base to the power of start and ends with base to the power of stop.

```APIDOC
## logspace

### Description
Return numbers spaced evenly on a log scale. In linear space, the sequence starts at base ** start (base to the power of start) and ends with base ** stop.

### Parameters
#### Path Parameters
- **start** (_float_) - Required - Base ** start is the starting value of the sequence.
- **stop** (_float_) - Required - Base ** stop is the final value of the sequence, unless _endpoint_ is False. In that case, num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of length num) are returned.
#### Query Parameters
- **num** (_int_) - Optional - Number of samples to generate. Default is 50. Must be non-negative.
- **base** (_float_) - Optional - The base of the log space. The step size between the elements in ln(samples) / ln(base) (or log_base(samples)) is uniform. Default is 10.0.
- **endpoint** (_boolean_) - Optional - If true, stop is the last sample. Otherwise, it is not included. Default is True.
- **dtype** (_dtype_) - Optional - The type of output array. If dtype is not given, infer the data type from the other input arguments.

### Returns
- **MIArray** - Array of evenly spaced values.

### Examples
```python
>>> logspace(2.0, 3.0, num=4)
array([100.0, 215.4434295785405, 464.1589682991224, 1000.0])
>>> logspace(2.0, 3.0, num=4, base=2.0)
array([4.0, 5.0396839219614975, 6.349604557649573, 8.0])
```
```

--------------------------------

### Run MeteoInfoLab on Windows

Source: http://meteothink.org/docs/introduction.html

Launch MeteoInfoLab on Windows by double-clicking the executable or running the batch command file. The batch file can also execute Jython scripts.

```batch
milab.bat test.py
```

--------------------------------

### Add Web Map Layer Example

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/webmap.html

Demonstrates how to add a web map layer using the webmap function. It includes setting up axes, adding a web map with a specific provider, loading and displaying shape data, and setting the map extent and title.

```python
#Add a map axes with mercator projection
axesm(position=[0,0,1,1], proj='merc', griddx=5, griddy=5)
#Add a web map layer
wlayer = webmap(provider='BingHybridMap')
#Add a shape layer
lchina = shaperead('D:/Temp/Map/bou2_4p.shp')
geoshow(lchina, edgecolor='b')
#Set lon/lat extent
axism([110, 130, 35, 45])
title('Web map example')
```

--------------------------------

### dimension

Source: http://meteothink.org/docs/meteoinfolab/dataset/midata.html

Gets the dimension information of a dataset.

```APIDOC
## dimension

### Description
Gets the dimension information of a dataset.

### Method
Not specified (likely a Python function call)

### Endpoint
Not applicable (Python module function)

### Parameters
- **dataset** (object) - Required - The dataset object.

### Request Example
```python
dims = midata.dimension(my_dataset)
```

### Response
- **dims** (object) - An object containing the dimension information.
```

--------------------------------

### Horizontal Bar Plot Example

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/barh.html

This example demonstrates how to create a horizontal bar plot with two series, 'Men' and 'Women', including error bars and custom labels. Ensure necessary imports like 'arange', 'axes', 'ylim', 'xlim', 'xlabel', 'yticks', 'legend', and 'title' are available.

```python
menMeans = [20, 35, 30, 35, 27]
std_men = (2, 3, 4, 1, 2)
n = len(menMeans)
ind = arange(n)
height = 0.35
gap = 0.06
axes(outerposition=[0,0,1,1])
barh(ind, menMeans, height, xerr=std_men, color='r', label='Men', \
    edgecolor=None)

womenMeans = [25, 32, 34, 20, 25]
std_women = (3, 5, 2, 3, 3)
barh(ind + height + gap, womenMeans, height, xerr=std_women, color='y', \
    label='Women', edgecolor='b', linewidth=2)

ylim(-0.2, 5)
xlim(0, 40)
xlabel('Mean age')
yticks(ind + height + gap * 0.5, ['G1','G2','G3','G4','G5'])
legend(markerscale=2, frameon=False)
title('Bar chart example')
```

--------------------------------

### Power Law Fitting and Plotting

Source: http://meteothink.org/docs/meteoinfolab/numeric/fitting/powerfit.html

This example demonstrates how to read data, perform power law fitting using `fitting.powerfit`, and then plot the original data along with the fitted curve using `fitting.predict`. It also displays the fitting parameters and R-squared value on the plot.

```python
from mipylib.numeric import fitting

fn = 'D:/Temp/ascii/PM&vis-1.txt'
col = numasciicol(fn)
nrow = numasciirow(fn)
a = asciiread(fn,shape=(nrow,ncol))
x=a[:,0]
y=a[:,1]
z=a[:,2]
axes(tickfontsize=17)
ls=scatter(x,y,s=8,c=z,cmap='NCV_jet',edgecolor=None,cnum=20)
xlim(0,450)
ylim(0,30)
xlabel(r'$
m{PM_{2.5}} 	o 
m{ (μ g 	o m^{-3})}$',fontsize=17)
ylabel(r'$
m{Visibility (km)}$',fontname='Arial',fontsize=17)
colorbar(ls,fontsize=17,label='RH(%)')

#Pow law fitting
a,b,r,f = fitting.powerfit(x, y, func=True)

#Plot fitting line
xx = linspace(x.min(), x.max(), 100)
#yy = a*pow(xx, b)
yy = fitting.predict(f, xx)
plot(xx, yy, '-b', linewidth=2)
text(250, 20, r'$y = ' + '%.4f' % a + 'x^{%.4f' % b + '}$', fontsize=16)
text(250, 18, r'$r^2=%.4f' % r + '$', fontsize=16)
```

--------------------------------

### MILayer Class

Source: http://meteothink.org/docs/meteoinfolab/geolib/milayer/milayer.html

Represents a map layer with methods to get and set attribute table cell values.

```APIDOC
## MILayer Class

### Description
Represents a map layer. It is initialized with a MapLayer object and a shape type.

### Parameters
* **layer** (_MapLayer_) - MapLayer object.
* **shapetype** (_ShapeTypes_) - Shape type [‘point’ | ‘line’ | ‘polygon’]

### Methods
#### `cellvalue(fieldname, shapeindex)`

##### Description
Get attribute table cell value.

##### Parameters
* **fieldname** (_string_) - Field name.
* **shapeindex** (_int_) - Shape index.

##### Returns
The value in attribute table identified by field name and shape index.

#### `setcellvalue(fieldname, shapeindex, value)`

##### Description
Set cell value in attribute table.

##### Parameters
* **fieldname** (_string_) - Field name.
* **shapeindex** (_int_) - Shape index.
* **value** (_object_) - Cell value to be assigned.
```

--------------------------------

### Run MeteoInfoLab on Linux/Unix

Source: http://meteothink.org/docs/introduction.html

Execute MeteoInfoLab from the shell command line, allocating 1 GB of memory. To run a script, append the script name. For headless execution, use the -b flag.

```bash
./milab.sh
```

```bash
./milab.sh test.py
```

```bash
./milab.sh -b test.py
```

--------------------------------

### Get Scalar Value by Position

Source: http://meteothink.org/docs/meteoinfolab/userguide/dataframe.html

Retrieves a single scalar value from the DataFrame using integer-based indexing with .iloc.

```python
>>> df.iloc[1,1]
0.6977123432245299
```

--------------------------------

### Run MeteoInfoLab on Mac OS

Source: http://meteothink.org/docs/introduction.html

Launch MeteoInfoLab on Mac OS using the provided shell script.

```bash
./milab_mac.sh
```

--------------------------------

### Slice Rows by Date String

Source: http://meteothink.org/docs/meteoinfolab/userguide/dataframe.html

Slices rows from a DataFrame using date strings. Both the start and end dates are inclusive.

```python
>>> df['20130102':'20130104']
                   A         B         C         D
2013-01-02  0.448598  0.697712  0.277767  0.759961
2013-01-03  0.219245  0.920414  0.886056  0.222002
2013-01-04  0.883879  0.439466  0.392876  0.994732
```

--------------------------------

### Create Array with Linear Spacing

Source: http://meteothink.org/docs/meteoinfolab/numeric/minum.html

Creates an array with a specified number of evenly spaced values between a start and end point.

```APIDOC
## linspace

### Description
Creates an array with a specified number of evenly spaced values between a start and end point.

### Function Signature
`linspace(start, stop, num=50)`

### Parameters
- **start** (numeric) - The starting value of the sequence.
- **stop** (numeric) - The end value of the sequence.
- **num** (int, optional) - The number of samples to generate. Defaults to 50.

### Returns
- An array of evenly spaced values.
```

--------------------------------

### Create Array with linspace

Source: http://meteothink.org/docs/meteoinfolab/userguide/arrays.html

Generate arrays with a specified number of elements evenly spaced between a start and end point using `linspace`.

```python
>>> linspace(0, 2, 9)                 # 9 numbers from 0 to 2
array([0., 0.25, 0.5, 0.75, 1., 1.25, 1.5, 1.75, 2.])
```

```python
>>> x = linspace(0, 2*pi, 100)        # useful to evaluate function at lots of points
>>> f = sin(x)
```

--------------------------------

### Create and Assign Variables

Source: http://meteothink.org/docs/meteoinfolab/userguide/gui.html

Use these commands in the console to create and assign values to variables.

```python
>>> a = 1
>>> b = 2
```

--------------------------------

### mipylib.numeric.minum.arange

Source: http://meteothink.org/docs/meteoinfolab/numeric/functions/arange.html

Returns evenly spaced values within a given interval. Values are generated within the half-open interval [start, stop).

```APIDOC
## mipylib.numeric.minum.arange

### Description
Returns evenly spaced values within a given interval. Values are generated within the half-open interval `[start, stop)`.

### Parameters
#### Parameters
- **start** (_number, optional_) - Start of interval. The interval includes this value. The default start value is 0.
- **stop** (_number_) - End of interval. The interval does not include this value, except in some cases where _step_ is not an integer and floating point round-off affects the length of _out_.
- **step** (_number, optional_) - Spacing between values. For any output _out_ , this is the distance between two adjacent values, `out[i+1] - out[i]`. The default step size is 1. If _step_ is specified. _start_ must also be given.
- **dtype** (_dtype_) - The type of output array. If dtype is not given, infer the data type from the other input arguments.

### Returns
- **MIArray** - Array of evenly spaced values.

### Examples
```python
>>> arange(3)
array([0, 1, 2])
>>> arange(3,7,2)
array([3, 5])
```
```

--------------------------------

### Get Scalar Value by Label

Source: http://meteothink.org/docs/meteoinfolab/userguide/dataframe.html

Retrieves a single scalar value from the DataFrame using label-based indexing with .at for fast access.

```python
>>> df.at[dates[0],'A']
0.730519863614471
```

--------------------------------

### Basic semilogx plot with grid and labels

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/semilogx.html

This example demonstrates how to create a basic semilogx plot using sample data. It includes enabling the grid, setting axis labels, adding a legend, and configuring minor ticks for both axes.

```python
t = arange(0.01, 20.0, 0.01)
semilogx(t, sin(2*pi*t))
grid(True)
ylabel('Y Axis')
xlabel('X Axis')
legend()
set(plt.gca, xminortick=True, yminortick=True)
title('Semilogx')
```

--------------------------------

### Get last 5 rows of DataFrame

Source: http://meteothink.org/docs/meteoinfolab/dataframe/dataframe/tail.html

Use the tail() method without arguments to retrieve the last 5 rows of the DataFrame.

```python
>>> df.tail()
      animal
4     monkey
5     parrot
6      shark
7      whale
8      zebra


```

--------------------------------

### Run MeteoInfoMap on Linux/Unix

Source: http://meteothink.org/docs/introduction.html

Execute MeteoInfoMap from the shell command line, allocating 1 GB of memory. Ensure you are in the directory containing the executable files.

```bash
./mimap.sh
```

--------------------------------

### 1D Interpolation with Linear and Cubic Methods

Source: http://meteothink.org/docs/meteoinfolab/numeric/interpolate/interp1d.html

Demonstrates how to use interp1d for both linear and cubic interpolation. It shows the setup of data points, the creation of interpolating functions, and plotting the original data against the interpolated results.

```python
from mipylib.numeric import interpolate

x = linspace(0, 10, num=11, endpoint=True)
y = cos(-x**2/9.0)
f = interpolate.interp1d(x, y)
f2 = interpolate.interp1d(x, y, kind='cubic')

xnew = linspace(0, 10, num=100, endpoint=True)
plot(x, y, 'bo', xnew, f(xnew), 'g-', xnew, f2(xnew), 'r--')
ylim(-1.5, 1.2)
legend(['data','linear','cubic'], loc='lower left')
title('Interpolation example')
```

--------------------------------

### mipylib.plotlib.miplot.arrowline

Source: http://meteothink.org/docs/meteoinfolab/plot/functions/arrowline.html

Adds an arrow line to the axes. This function allows for the creation of arrow graphics with specified start points, lengths, and optional styling.

```APIDOC
## mipylib.plotlib.miplot.arrowline

### Description
Add an arrow line to the axes.

### Parameters
#### Positional Parameters
- **_x_** (_float or array_like_) - X coordinates.
- **_y_** (_float or array_like_) - Y coordinates.

#### Keyword Parameters
- **_dx_** (_float_) - The length of arrow along x direction. Only valid when x is float. Defaults to 0.
- **_dy_** (_float_) - The length of arrow along y direction. Only valid when y is float. Defaults to 0.

### Returns
Arrow line graphic.

### Example
```python
v = [-0.2, 0, .2, .4, .6, .8, 1, 1.2]
for i, overhang in enumerate(v):
    arrowline(.1,overhang,.6,0, headwidth=20,overhang=overhang)

xlim(0, 1)
ylim(-0.3, 1.3)
yticks(v)
xticks([])
ylabel('overhang')
antialias(True)
```

```python
x = [1,2,3]
y = [4,3,5]
arrowline(x, y, color='b', iscurve=True, headwidth=10)
xlim(0, 4)
ylim(2, 6)
antialias(True)
```
```
Tokens:
Raw