def __call__(self, x, strip_zeros=True):
import numpy.core.numeric as _nc
err = _nc.seterr(invalid='ignore')
try:
if isnan(x):
if self.sign:
return self.special_fmt % ('+' + _nan_str,)
else:
return self.special_fmt % (_nan_str,)
elif isinf(x):
if x > 0:
if self.sign:
return self.special_fmt % ('+' + _inf_str,)
else:
return self.special_fmt % (_inf_str,)
else:
return self.special_fmt % ('-' + _inf_str,)
finally:
_nc.seterr(**err)
s = self.format % x
if self.large_exponent:
# 3-digit exponent
expsign = s[-3]
if expsign == '+' or expsign == '-':
s = s[1:-2] + '0' + s[-2:]
elif self.exp_format:
# 2-digit exponent
if s[-3] == '0':
s = ' ' + s[:-3] + s[-2:]
elif strip_zeros:
z = s.rstrip('0')
s = z + ' ' * (len(s) - len(z))
return s
def fillFormat(self, data):
import numpy.core.numeric as _nc
errstate = _nc.seterr(all='ignore')
try:
special = isnan(data) | isinf(data)
valid = not_equal(data, 0) & ~special
non_zero = absolute(data.compress(valid))
if len(non_zero) == 0:
max_val = 0.
min_val = 0.
else:
max_val = maximum.reduce(non_zero)
min_val = minimum.reduce(non_zero)
if max_val >= 1.e8:
self.exp_format = True
if not self.suppress_small and (min_val < 0.0001
or max_val / min_val > 1000.):
self.exp_format = True
finally:
_nc.seterr(**errstate)
if self.exp_format:
self.large_exponent = 0 < min_val < 1e-99 or max_val >= 1e100
self.max_str_len = 8 + self.precision
if self.large_exponent:
self.max_str_len += 1
if self.sign:
format = '%+'
else:
format = '%'
format = format + '%d.%de' % (self.max_str_len, self.precision)
else:
format = '%%.%df' % (self.precision,)
if len(non_zero):
precision = max([_digits(x, self.precision, format)
for x in non_zero])
else:
precision = 0
precision = min(self.precision, precision)
self.max_str_len = len(str(int(max_val))) + precision + 2
if _nc.any(special):
self.max_str_len = max(self.max_str_len,
len(_nan_str),
len(_inf_str) + 1)
if self.sign:
format = '%#+'
else:
format = '%#'
format = format + '%d.%df' % (self.max_str_len, precision)
self.special_fmt = '%%%ds' % (self.max_str_len,)
self.format = format
def __init__(self, float_conv=float,int_conv=int,
float_to_float=float,
float_to_str = lambda v:'%24.16e' % v,
title = 'Python floating point number'):
"""
float_conv - convert integer to float (array)
int_conv - convert float (array) to integer
float_to_float - convert float array to float
float_to_str - convert array float to str
title - description of used floating point numbers
"""
# We ignore all errors here because we are purposely triggering
# underflow to detect the properties of the runninng arch.
saverrstate = seterr(under='ignore')
try:
self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)
finally:
seterr(**saverrstate)
def __init__(self, float_conv=float,int_conv=int,
float_to_float=float,
float_to_str = lambda v:'%24.16e' % v,
title = 'Python floating point number'):
"""
float_conv - convert integer to float (array)
int_conv - convert float (array) to integer
float_to_float - convert float array to float
float_to_str - convert array float to str
title - description of used floating point numbers
"""
# We ignore all errors here because we are purposely triggering
# underflow to detect the properties of the runninng arch.
saverrstate = seterr(under='ignore')
try:
self._do_init(float_conv, int_conv, float_to_float, float_to_str, title)
finally:
seterr(**saverrstate)
def _get_datetime(self,str_date,str_time):
str_d=str_date + " " + str_time;
if "." in str_d :
parts = str_d.split('.')[0];
if (len(re.findall("\D\D\d\d\d",parts))>0): #ignore lines for which splits are improper
return None;
elif len(re.findall("\D\D\d\d\d",str_d))>0: #the the split is improper(has sensor id), ignore it
print "Ignoring line "+ str_d
dt=None;
return dt;
else:
parts=str_d;
try:
dt = datetime.datetime.strptime(parts, "%Y-%m-%d %H:%M:%S")
except ValueError as e:
print(str_date);print(str_time)
print("happy testing line 101 101 101")
seterr("Cannot parse the date .Quit!");
return dt;
def __init__(self,fileName):
self.mask = imread(fileName) > 0
self.notMask = logical_not(self.mask)
self.positives = count_nonzero(self.mask)*1.0
self.negatives = (self.mask.size - self.positives)*1.0
def checkClassification(self,binary):
fp = count_nonzero(logical_and(self.notMask, binary))
tp = count_nonzero(logical_and(self.mask,binary))
return fp,tp
def getBlackWhiteFromBinary(img):
return dstack((img,img,img))
if __name__ == '__main__':
seterr(all='warn')
skindata, nonskindata = loadmat('data/skin.mat')['sdata'].reshape((-1, 3)).astype(float128), loadmat('data/nonskin.mat')['ndata'].reshape((-1, 3)).astype(float128)
iters = 10
show = False
usekmeans = False
gmmskin, gmmnonskin = gmmEM(skindata, 2, iters,show,usekmeans), gmmEM(nonskindata, 2, iters,show,usekmeans)
img = imread('data/image.png').astype(float128) / 255.0
imshape = img.shape
img = img.reshape((-1, 3))
skinp, nonskinp = gmmskin.getP(img), gmmnonskin.getP(img)
res = skinp > nonskinp
res = res.reshape((imshape[0],imshape[1]))
res = logical_not(res)
gt = GroundTruth('data/mask.png')
fp, tp = gt.checkClassification(res)
