def get_zrange(self,
zrange=[None, None],
xrange=[None, None],
yrange=[None, None],
scale='linear'):
x, y, z = self._eval_xy()
if (xrange[0] is not None and xrange[1] is not None
and yrange[0] is not None and yrange[1] is not None):
if x.size * y.size == z.size:
idx1 = np.where((y >= yrange[0]) & (y <= yrange[1]))[0]
idx2 = np.where((x >= xrange[0]) & (x <= xrange[1]))[0]
if (len(idx1) == 0 or len(idx2) == 0):
if (zrange[0] is None and zrange[1] is None):
# this is for safety maybe not necessary
if scale == 'log':
z = mask_negative(z)
self._update_range(
zrange, [np.nanmin(z), np.nanmax(z)])
zrange = update_zrange(z)
else:
zt = z[idx1, :]
zt = zt[:, idx2]
if scale == 'log':
zt = mask_negative(zt)
self._update_range(zrange, [np.nanmin(zt), np.nanmax(zt)])
else:
self._update_range(zrange, [np.nanmin(z), np.nanmax(z)])
return zrange
def get_zrange(self, zrange=[None,None],
xrange=[None,None],
yrange=[None,None],
scale = 'linear'):
x, y, z = self._eval_xy()
if (xrange[0] is not None and
xrange[1] is not None and
yrange[0] is not None and
yrange[1] is not None):
if x.size*y.size == z.size:
idx1 = np.where((y >= yrange[0]) & (y <= yrange[1]))[0]
idx2 = np.where((x >= xrange[0]) & (x <= xrange[1]))[0]
if (len(idx1) == 0 or len(idx2) == 0):
if (zrange[0] is None and
zrange[1] is None):
### this is for safety maybe not necessary
if scale == 'log': z = mask_negative(z)
self._update_range(zrange, [np.nanmin(z), np.nanmax(z)])
zrange = update_zrange(z)
else:
zt = z[idx1,:]
zt = zt[:, idx2]
if scale == 'log': zt = mask_negative(zt)
self._update_range(zrange, [np.nanmin(zt), np.nanmax(zt)])
else:
self._update_range(zrange, [np.nanmin(z), np.nanmax(z)])
return zrange
def get_xrange(self, xrange=[None, None], scale='linear'):
if self._mpl_cmd == 'fill':
x, y, s = self._eval_xy()
if x is None:
return
if scale == 'log':
x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
elif self._mpl_cmd == 'fill_between':
x, y, y2, where = self._eval_xy()
if x is None:
return
if scale == 'log':
x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
elif self._mpl_cmd == 'fill_betweenx':
y, x, x2, where = self._eval_xy()
if x is None:
return
if x2 is None:
return
if scale == 'log':
x = mask_negative(x)
x2 = mask_negative(x2)
return self._update_range(xrange, [
np.nanmin([np.nanmin(x), np.nanmin(x2)]),
np.nanmax([np.nanmax(x), np.nanmax(x2)])
])
def get_crange(self, crange=[None, None],
xrange=[None, None],
yrange=[None, None],
scale='linear'):
x, y, z = self._eval_xyz()
if np.iscomplex(z).any():
z = z.astype(np.float)
if self.get_figaxes().get_3d():
crange = self._update_range(crange,
(np.amin(z), np.amax(z)))
return crange
if (xrange[0] is not None and
xrange[1] is not None and
yrange[0] is not None and
yrange[1] is not None):
if x.size*y.size == z.size:
idx1 = np.where((y >= yrange[0]) & (y <= yrange[1]))[0]
idx2 = np.where((x >= xrange[0]) & (x <= xrange[1]))[0]
if (len(idx1) == 0 or len(idx2) == 0):
if (crange[0] is None and
crange[1] is None):
# this is for safety maybe not necessary
if scale == 'log':
z = mask_negative(z)
crange = self._update_range(crange,
(np.min(z), np.max(z)))
else:
zt = z[idx1, :]
zt = zt[:, idx2]
if scale == 'log':
zt = mask_negative(zt)
crange = self._update_range(crange,
(np.nanmin(zt), np.nanmax(zt)))
elif x.size == z.size and y.size == z.size:
idx1 = np.where((y.flatten() >= yrange[0]) & (y.flatten() <= yrange[1]) &
(x.flatten() >= xrange[0]) & (x.flatten() <= xrange[1]))[0]
if (len(idx1) == 0):
if scale == 'log':
zt = mask_negative(zt)
crange = self._update_range(crange,
(min(zt), max(zt)))
else:
zt = z.flatten()[idx1]
if scale == 'log':
zt = mask_negative(zt)
crange = self._update_range(crange,
(np.amin(zt), np.amax(zt)))
else:
# if len(_tri) == len(z), it comes here
crange = self._update_range(crange,
(np.nanmin(z), np.nanmax(z)))
return crange
def get_xrange(self, xrange=[None, None], scale='linear'):
x, y = self._eval_xy()
if len(self._artists) != 0:
xc = self._artists[0].get_xdata()
else:
xc, yc = calc_xy(x, y, mesh=self._mesh, mode=self._sp_interp)
if scale == 'log':
x = mask_negative(x)
xc = mask_negative(xc)
return self._update_range(xrange, [
np.nanmin([np.nanmin(x), np.nanmin(xc)]),
np.nanmax([np.nanmax(x), np.nanmax(xc)])
])
def get_xrange(self, xrange=[None,None], scale = 'linear'):
x, y = self._eval_xy()
if len(self._artists) != 0:
xc = self._artists[0].get_xdata()
else:
xc, yc = calc_xy(x, y,
mesh = self._mesh,
mode=self._sp_interp)
if scale == 'log':
x = mask_negative(x)
xc = mask_negative(xc)
return self._update_range(xrange, [np.nanmin([np.nanmin(x), np.nanmin(xc)]),
np.nanmax([np.nanmax(x), np.nanmax(xc)])])
def get_crange(self, crange=[None,None],
xrange=[None,None],
yrange=[None,None],
scale='linear'):
x, y, z = self._eval_xyz()
if np.iscomplex(z).any():
z = z.astype(np.float)
if (xrange[0] is not None and
xrange[1] is not None and
yrange[0] is not None and
yrange[1] is not None):
if x.size*y.size == z.size:
idx1 = np.where((y >= yrange[0]) & (y <= yrange[1]))[0]
idx2 = np.where((x >= xrange[0]) & (x <= xrange[1]))[0]
if (len(idx1) == 0 or len(idx2) == 0):
if (crange[0] is None and
crange[1] is None):
### this is for safety maybe not necessary
if scale == 'log': z = mask_negative(z)
crange = self._update_range(crange,
(np.min(z), np.max(z)))
else:
zt = z[idx1,:]
zt = zt[:, idx2]
if scale == 'log': zt = mask_negative(zt)
crange = self._update_range(crange,
(np.nanmin(zt), np.nanmax(zt)))
elif x.size == z.size and y.size == z.size:
idx1 = np.where((y.flatten() >= yrange[0]) & (y.flatten() <= yrange[1]) &
(x.flatten() >= xrange[0]) & (x.flatten() <= xrange[1]))[0]
if (len(idx1) == 0):
if scale == 'log': zt = mask_negative(zt)
crange = self._update_range(crange,
(min(zt), max(zt)))
else:
zt = z.flatten()[idx1]
if scale == 'log': zt = mask_negative(zt)
crange = self._update_range(crange,
(np.amin(zt), np.amax(zt)))
else:
# if len(_tri) == len(z), it comes here
crange = self._update_range(crange,
(np.nanmin(z), np.nanmax(z)))
return crange
def get_xrange(self, xrange=[None, None], scale='linear'):
x, y = self._eval_xy()
if scale == 'log': x = mask_negative(x)
if x.size > 0:
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
else:
return super(FigAxline, self).get_xrange(xrange, scale=scale)
def get_yrange(self, yrange=[None, None], xrange=[None, None], scale='linear'):
x, y, z = self._eval_xyz()
if y is None:
return yrange
if scale == 'log':
y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
def get_xrange(self, xrange=[None, None], scale='linear'):
x, y, z = self._eval_xy()
if x is None:
return xrange
if scale == 'log':
x = mask_negative(x)
return self._update_range(xrange, (np.nanmin(x), np.nanmax(x)))
def get_xrange(self, xrange=[None, None], scale='linear'):
x, y, z, u, v, w = self._eval_xyzw() # this handles "use_var"
if x is None:
return
if scale == 'log':
x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
def get_xrange(self, xrange=[None,None], scale='linear'):
x, y = self._eval_xy()
if scale == 'log': x = mask_negative(x)
if x.size > 0:
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
else:
return super(FigAxline, self).get_xrange(xrange, scale=scale)
def get_crange(self, crange=[None,None],
xrange=[None,None],
yrange=[None,None], scale = 'linear'):
if self._mpl_cmd == 'plot':
x, y, z, s, c = self._eval_xy()
else:
x, y, z, s, c, xerr, yerr = self._eval_xy()
if c is not None:
if scale == 'log': c = mask_negative(c)
crange = self._update_range(crange,
(np.nanmin(c) ,np.nanmax(c)))
else:
if z is not None and self.getp('cz'):
if scale == 'log': z= mask_negative(z)
crange = self._update_range(crange,
(np.nanmin(z) ,np.nanmax(z)))
return crange
def get_xrange(self, xrange=[None, None], scale='linear'):
x = self.getvar('x')
xrange = self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
return xrange
x, y, z = self._eval_xyz()
if x is None: return xrange
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
def get_yrange(self, yrange=[None, None],
xrange=[None, None], scale = 'linear'):
# de = self.get_data_extent()
x, y, z = self._eval_xyz()
if x is None: return yrange
if y is None: return yrange
if scale == 'log': y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
def get_yrange(self, yrange=[None,None], xrange=[None, None], scale = 'linear'):
x, y = self._eval_xy()
if scale == 'log': y = mask_negative(y)
if y.size != 0:
return self._update_range(yrange, [np.nanmin(y), np.nanmax(y)])
else:
return super(FigAxspan, self).get_yrange(yrange=yrange,
xrange = xrange, scale=scale)
def get_yrange(self, yrange=[None, None],
xrange=[None, None], scale='linear'):
# de = self.get_data_extent()
x, y, z, u, v, w = self._eval_xyzw() # this handles "use_var"
if y is None:
return
if scale == 'log':
y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
def get_zrange(self, zrange=[None, None],
xrange=[None, None],
yrange=[None, None], scale='linear'):
x, y, z, u, v, w = self._eval_xyzw() # this handles "use_var"
if z is None:
return
if scale == 'log':
z = mask_negative(z)
return self._update_range(zrange, (np.nanmin(z), np.nanmax(z)))
def get_crange(self,
crange=[None, None],
xrange=[None, None],
yrange=[None, None],
scale='linear'):
if self._mpl_cmd == 'plot':
x, y, z, s, c = self._eval_xy()
else:
x, y, z, s, c, xerr, yerr = self._eval_xy()
if c is not None:
if scale == 'log': c = mask_negative(c)
crange = self._update_range(crange, (np.nanmin(c), np.nanmax(c)))
else:
if z is not None and self.getp('cz'):
if scale == 'log': z = mask_negative(z)
crange = self._update_range(crange,
(np.nanmin(z), np.nanmax(z)))
return crange
def get_xrange(self, xrange=[None, None], scale='linear'):
if (self.getvar('offset') is not None and
self.getvar('zdir') == 'x'):
return self._update_range(xrange, (self.getvar('offset'),
self.getvar('offset'),))
x, y, z = self._eval_xyz()
if x is None: return
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
def get_xrange(self, xrange=[None,None], scale = 'linear'):
# de = self.get_data_extent()[0:2]
# if de is not None:
if self._mpl_cmd == 'plot':
x, y, z, s, c = self._eval_xy() # this handles "use_var"
else:
x, y, z, s, c, xerr, yerr = self._eval_xy() # this handles "use_var"
if x is None: return
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
def get_xrange(self, xrange=[None, None], scale='linear'):
if (self.getvar('offset') is not None and self.getvar('zdir') == 'x'):
return self._update_range(xrange, (
self.getvar('offset'),
self.getvar('offset'),
))
x, y, z = self._eval_xyz()
if x is None: return
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
def get_xrange(self, xrange=[None, None], scale='linear'):
# de = self.get_data_extent()[0:2]
# if de is not None:
if self._mpl_cmd == 'plot':
x, y, z, s, c = self._eval_xy() # this handles "use_var"
else:
x, y, z, s, c, xerr, yerr = self._eval_xy(
) # this handles "use_var"
if x is None: return
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
def get_xrange(self, xrange=[None,None], scale='linear'):
if self._mpl_cmd == 'fill':
x, y, s = self._eval_xy()
if x is None: return
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
elif self._mpl_cmd == 'fill_between':
x, y, y2, where = self._eval_xy()
if x is None: return
if scale == 'log': x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
elif self._mpl_cmd == 'fill_betweenx':
y, x, x2, where = self._eval_xy()
if x is None: return
if x2 is None: return
if scale == 'log':
x = mask_negative(x)
x2 = mask_negative(x2)
return self._update_range(xrange, [np.nanmin([np.nanmin(x), np.nanmin(x2)]),
np.nanmax([np.nanmax(x), np.nanmax(x2)])])
def get_zrange(self, zrange=[None,None],
xrange=[None,None],
yrange=[None,None], scale = 'linear'):
if self._mpl_cmd == 'plot':
x, y, z, s, c = self._eval_xy()
else:
x, y, z, s, c, xerr, yerr = self._eval_xy()
if z is not None:
if scale == 'log': z = mask_negative(z)
zrange = self._update_range(zrange, (np.nanmin(z), np.nanmax(z)))
return zrange
def get_yrange(self, yrange=[None, None],
xrange=[None, None], scale = 'linear'):
# de = self.get_data_extent()
if (self.getvar('offset') is not None and
self.getvar('zdir') == 'y'):
return self._update_range(yrange, (self.getvar('offset'),
self.getvar('offset'),))
x, y, z = self._eval_xyz()
if x is None: return
if y is None: return
if scale == 'log': y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
def get_zrange(self,
zrange=[None, None],
xrange=[None, None],
yrange=[None, None],
scale='linear'):
if self._mpl_cmd == 'plot':
x, y, z, s, c = self._eval_xy()
else:
x, y, z, s, c, xerr, yerr = self._eval_xy()
if z is not None:
if scale == 'log': z = mask_negative(z)
zrange = self._update_range(zrange, (np.nanmin(z), np.nanmax(z)))
return zrange
def get_xrange(self, xrange=[None, None], scale='linear'):
x, y, z = self._eval_xyz()
if x is None:
return xrange
if not self.get_figaxes().get_3d():
if scale == 'log':
x = mask_negative(x)
return self._update_range(xrange, [np.nanmin(x), np.nanmax(x)])
else:
im_center, ax1, ax2 = self._get_3d_placement()
data = np.hstack([im_center[0] + ax1[0]*x, im_center[0] + ax2[0]*y])
xrange = self._update_range(xrange,
(np.nanmin(data), np.nanmax(data)))
return xrange
def get_crange(self, crange=[None,None],
xrange=[None,None],
yrange=[None,None],
scale='linear'):
if len(self._artists) == 0:
return FigImage.get_crange(self, crange = crange,
xrange = xrange, yrange = yrange,
scale = scale)
else:
zt = self._artists[0].get_array()
if scale == 'log': zt = mask_negative(zt)
crange = self._update_range(crange,
(min(zt), max(zt)))
return crange
def get_yrange(self,
yrange=[None, None],
xrange=[None, None],
scale='linear'):
if self._n is not None:
return self._update_range(yrange, (0, np.nanmax(self._n)))
else:
return yrange
# de = self.get_data_extent()
x, y, z = self._eval_xyz()
if x is None: return yrange
if y is None: return yrange
if scale == 'log': y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
def calc_yrange(x, y, xrange, yrange, scale):
# x.ndim = 1, y.ndim = 1 in this func
xidx = np.isfinite(x)
idx = (np.where((x[xidx] >= xrange[0]) & (x[xidx] <= xrange[1])))
check = False
for ar in idx:
if len(ar) == 0: check = True
if check: return yrange
yy = y[xidx][idx]
if scale == 'log': yy = mask_negative(yy)
y0n = np.nanmin(yy)
y1n = np.nanmax(yy)
yrange = self._update_range(yrange, (y0n, y1n))
return yrange
def get_yrange(self,
yrange=[None, None],
xrange=[None, None],
scale='linear'):
# de = self.get_data_extent()
if (self.getvar('offset') is not None and self.getvar('zdir') == 'y'):
return self._update_range(yrange, (
self.getvar('offset'),
self.getvar('offset'),
))
x, y, z = self._eval_xyz()
if x is None: return
if y is None: return
if scale == 'log': y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
def get_crange(self,
crange=[None, None],
xrange=[None, None],
yrange=[None, None],
scale='linear'):
if len(self._artists) == 0:
return FigImage.get_crange(self,
crange=crange,
xrange=xrange,
yrange=yrange,
scale=scale)
else:
zt = self._artists[0].get_array()
if scale == 'log': zt = mask_negative(zt)
crange = self._update_range(crange, (min(zt), max(zt)))
return crange
def calc_yrange(x, y, xrange, yrange, scale):
# x.ndim = 1, y.ndim = 1 in this func
xidx = np.isfinite(x)
idx = (np.where((x[xidx] >= xrange[0]) &
(x[xidx] <= xrange[1])))
check = False
for ar in idx:
if len(ar) == 0: check = True
if check: return yrange
yy = y[xidx][idx]
if scale == 'log': yy = mask_negative(yy)
y0n=np.nanmin(yy)
y1n=np.nanmax(yy)
yrange = self._update_range(yrange, (y0n, y1n))
return yrange
def get_yrange(self, yrange=[None, None],
xrange=[None, None], scale='linear'):
# de = self.get_data_extent()
x, y, z = self._eval_xyz()
if x is None:
return yrange
if y is None:
return yrange
if not self.get_figaxes().get_3d():
if scale == 'log':
y = mask_negative(y)
return self._update_range(yrange, (np.nanmin(y), np.nanmax(y)))
else:
im_center, ax1, ax2 = self._get_3d_placement()
data = np.hstack([im_center[1] + ax1[1]*x, im_center[0] + ax2[1]*y])
yrange = self._update_range(yrange,
(np.nanmin(data), np.nanmax(data)))
return yrange
