def bytescale(data, cmin=None, cmax=None, high=255, low=0):
if data.typecode == _UInt8:
return data
high = high - low
if cmin is None:
cmin = amin(ravel(data))
if cmax is None:
cmax = amax(ravel(data))
scale = high *1.0 / (cmax-cmin or 1)
bytedata = ((data*1.0-cmin)*scale + 0.4999).astype(_UInt8)
return bytedata + cast[_UInt8](low)
def kstat(data,n=2):
"""Return the nth k-statistic (1<=n<=4 so far).
The nth k-statistic is the unique symmetric unbiased estimator of the nth
cumulant kappa_n
"""
if n>4 or n<1:
raise ValueError, "k-statistics only supported for 1<=n<=4"
n = int(n)
S = zeros(n+1,'d')
data = ravel(data)
N = len(data)
for k in range(1,n+1):
S[k] = sum(data**k)
if n==1:
return S[1]*1.0/N
elif n==2:
return (N*S[2]-S[1]**2.0)/(N*(N-1.0))
elif n==3:
return (2*S[1]**3 - 3*N*S[1]*S[2]+N*N*S[3]) / (N*(N-1.0)*(N-2.0))
elif n==4:
return (-6*S[1]**4 + 12*N*S[1]**2 * S[2] - 3*N*(N-1.0)*S[2]**2 - \
4*N*(N+1)*S[1]*S[3] + N*N*(N+1)*S[4]) / \
(N*(N-1.0)*(N-2.0)*(N-3.0))
else:
raise ValueError, "Should not be here."
def bayes_mvs(data,alpha=0.90):
"""Return Bayesian confidence intervals for the mean, var, and std.
Assumes 1-d data all has same mean and variance and uses Jeffrey's prior
for variance and std.
alpha gives the probability that the returned interval contains
the true parameter.
Uses peak of conditional pdf as starting center.
Returns (peak, (a, b)) for each of mean, variance and standard deviation.
"""
x = ravel(data)
n = len(x)
assert(n > 1)
n = float(n)
xbar = sb.add.reduce(x)/n
C = sb.add.reduce(x*x)/n - xbar*xbar
#
fac = sqrt(C/(n-1))
tval = distributions.t.ppf((1+alpha)/2.0,n-1)
delta = fac*tval
ma = xbar - delta
mb = xbar + delta
mp = xbar
#
fac = n*C/2.0
peak = 2/(n+1.)
a = (n-1)/2.0
F_peak = distributions.invgamma.cdf(peak,a)
q1 = F_peak - alpha/2.0
q2 = F_peak + alpha/2.0
if (q1 < 0): # non-symmetric area
q2 = alpha
va = 0.0
else:
va = fac*distributions.invgamma.ppf(q1,a)
vb = fac*distributions.invgamma.ppf(q2,a)
vp = peak*fac
#
fac = sqrt(fac)
peak = sqrt(2./n)
F_peak = distributions.gengamma.cdf(peak,a,-2)
q1 = F_peak - alpha/2.0
q2 = F_peak + alpha/2.0
if (q1 < 0):
q2 = alpha
sta = 0.0
else:
sta = fac*distributions.gengamma.ppf(q1,a,-2)
stb = fac*distributions.gengamma.ppf(q2,a,-2)
stp = peak*fac
return (mp,(ma,mb)),(vp,(va,vb)),(stp,(sta,stb))
def kstatvar(data,n=2):
"""Returns an unbiased estimator of the variance of the k-statistic: n=1 or 2
"""
data = ravel(data)
N = len(data)
if n==1:
return kstat(data,n=2)*1.0/N
elif n==2:
k2 = kstat(data,n=2)
k4 = kstat(data,n=4)
return (2*k2*k2*N + (N-1)*k4)/(N*(N+1))
else:
raise ValueError, "Only n=1 or n=2 supported."
def toimage(arr,high=255,low=0,cmin=None,cmax=None,pal=None,
mode=None,channel_axis=None):
"""Takes a Numeric array and returns a PIL image. The mode of the
PIL image depends on the array shape, the pal keyword, and the mode
keyword.
For 2-D arrays, if pal is a valid (N,3) byte-array giving the RGB values
(from 0 to 255) then mode='P', otherwise mode='L', unless mode is given
as 'F' or 'I' in which case a float and/or integer array is made
For 3-D arrays, the channel_axis argument tells which dimension of the
array holds the channel data.
For 3-D arrays if one of the dimensions is 3, the mode is 'RGB'
by default or 'YCbCr' if selected.
if the
The Numeric array must be either 2 dimensional or 3 dimensional.
"""
data = asarray(arr)
if iscomplexobj(data):
raise ValueError, "Cannot convert a complex-valued array."
shape = list(data.shape)
valid = len(shape)==2 or ((len(shape)==3) and \
((3 in shape) or (4 in shape)))
assert valid, "Not a suitable array shape for any mode."
if len(shape) == 2:
shape = (shape[1],shape[0]) # columns show up first
if mode == 'F':
image = Image.fromstring(mode,shape,data.astype('f').tostring())
return image
if mode in [None, 'L', 'P']:
bytedata = bytescale(data,high=high,low=low,cmin=cmin,cmax=cmax)
image = Image.fromstring('L',shape,bytedata.tostring())
if pal is not None:
image.putpalette(asarray(pal,typecode=_UInt8).tostring())
# Becomes a mode='P' automagically.
elif mode == 'P': # default gray-scale
pal = arange(0,256,1,typecode='b')[:,NewAxis] * \
ones((3,),typecode='b')[NewAxis,:]
image.putpalette(asarray(pal,typecode=_UInt8).tostring())
return image
if mode == '1': # high input gives threshold for 1
bytedata = ((data > high)*255).astype('b')
image = Image.fromstring('L',shape,bytedata.tostring())
image = image.convert(mode='1')
return image
if cmin is None:
cmin = amin(ravel(data))
if cmax is None:
cmax = amax(ravel(data))
data = (data*1.0 - cmin)*(high-low)/(cmax-cmin) + low
if mode == 'I':
image = Image.fromstring(mode,shape,data.astype('i').tostring())
else:
raise ValueError, _errstr
return image
# if here then 3-d array with a 3 or a 4 in the shape length.
# Check for 3 in datacube shape --- 'RGB' or 'YCbCr'
if channel_axis is None:
if (3 in shape):
ca = Numeric.nonzero(asarray(shape) == 3)[0]
else:
ca = Numeric.nonzero(asarray(shape) == 4)
if len(ca):
ca = ca[0]
else:
raise ValueError, "Could not find channel dimension."
else:
ca = channel_axis
numch = shape[ca]
if numch not in [3,4]:
raise ValueError, "Channel axis dimension is not valid."
bytedata = bytescale(data,high=high,low=low,cmin=cmin,cmax=cmax)
if ca == 2:
strdata = bytedata.tostring()
shape = (shape[1],shape[0])
elif ca == 1:
strdata = transpose(bytedata,(0,2,1)).tostring()
shape = (shape[2],shape[0])
elif ca == 0:
strdata = transpose(bytedata,(1,2,0)).tostring()
shape = (shape[2],shape[1])
if mode is None:
if numch == 3: mode = 'RGB'
else: mode = 'RGBA'
if mode not in ['RGB','RGBA','YCbCr','CMYK']:
raise ValueError, _errstr
if mode in ['RGB', 'YCbCr']:
assert numch == 3, "Invalid array shape for mode."
if mode in ['RGBA', 'CMYK']:
assert numch == 4, "Invalid array shape for mode."
# Here we know data and mode is coorect
image = Image.fromstring(mode, shape, strdata)
return image
