def __init__(self, **params):
"""
Initialize this object as an EventProcessor, then also as
a SheetCoordinateSystem with equal xdensity and ydensity.
views is an AttrTree, which stores associated measurements,
i.e. representations of the sheet for use by analysis or plotting
code.
"""
EventProcessor.__init__(self, **params)
# Initialize this object as a SheetCoordinateSystem, with
# the same density along y as along x.
SheetCoordinateSystem.__init__(self, self.nominal_bounds,
self.nominal_density)
n_units = round((self.lbrt[2] - self.lbrt[0]) * self.xdensity, 0)
if n_units < 1: raise ValueError(
"Sheet bounds and density must be specified such that the "+ \
"sheet has at least one unit in each direction; " \
+self.name+ " does not.")
# setup the activity matrix
self.activity = zeros(self.shape, activity_type)
# For non-plastic inputs
self.__saved_activity = []
self._plasticity_setting_stack = []
self.views = AttrTree()
self.views.Maps = AttrTree()
self.views.Curves = AttrTree()
def __init__(self,**params):
"""
Initialize this object as an EventProcessor, then also as
a SheetCoordinateSystem with equal xdensity and ydensity.
views is an AttrDict, which stores associated measurements,
i.e. representations of the sheet for use by analysis or plotting
code.
"""
EventProcessor.__init__(self,**params)
# Initialize this object as a SheetCoordinateSystem, with
# the same density along y as along x.
SheetCoordinateSystem.__init__(self,self.nominal_bounds,self.nominal_density)
n_units = round((self.lbrt[2]-self.lbrt[0])*self.xdensity,0)
if n_units<1: raise ValueError(
"Sheet bounds and density must be specified such that the "+ \
"sheet has at least one unit in each direction; " \
+self.name+ " does not.")
# setup the activity matrix
self.activity = zeros(self.shape,activity_type)
# For non-plastic inputs
self.__saved_activity = []
self._plasticity_setting_stack = []
self.views = AttrDict()
self.views['maps'] = AttrDict()
self.views['curves'] = AttrDict()
def _set_image(self,image):
# Stores a SheetCoordinateSystem with an activity matrix
# representing the image
if not isinstance(image,np.ndarray):
image = np.array(image,np.float)
rows,cols = image.shape
self.scs = SheetCoordinateSystem(xdensity=1.0,ydensity=1.0,
bounds=BoundingBox(points=((-cols/2.0,-rows/2.0),
( cols/2.0, rows/2.0))))
self.scs.activity=image
def situated(self):
if self.bounds.lbrt() == self.situated_bounds.lbrt():
return self
l, b, r, t = self.bounds.lbrt()
xd = int(np.round(self.data.shape[1] / (r - l)))
yd = int(np.round(self.data.shape[0] / (t - b)))
scs = SheetCoordinateSystem(self.situated_bounds, xd, yd)
data = np.zeros(scs.shape, dtype=np.float64)
r1, r2, c1, c2 = self.input_sheet_slice
data[r1:r2, c1:c2] = self.data
return ImagenSheetView(data,
self.situated_bounds,
roi_bounds=self.roi_bounds,
situated_bounds=self.situated_bounds,
label=self.label,
value=self.value)
class PatternSampler(ImageSampler):
"""
When called, resamples - according to the size_normalization
parameter - an image at the supplied (x,y) sheet coordinates.
(x,y) coordinates outside the image are returned as the background
value.
"""
whole_pattern_output_fns = param.HookList(class_=TransferFn,default=[],doc="""
Functions to apply to the whole image before any sampling is done.""")
background_value_fn = param.Callable(default=None,doc="""
Function to compute an appropriate background value. Must accept
an array and return a scalar.""")
size_normalization = param.ObjectSelector(default='original',
objects=['original','stretch_to_fit','fit_shortest','fit_longest'],
doc="""
Determines how the pattern is scaled initially, relative to the
default retinal dimension of 1.0 in sheet coordinates:
'stretch_to_fit': scale both dimensions of the pattern so they
would fill a Sheet with bounds=BoundingBox(radius=0.5) (disregards
the original's aspect ratio).
'fit_shortest': scale the pattern so that its shortest dimension
is made to fill the corresponding dimension on a Sheet with
bounds=BoundingBox(radius=0.5) (maintains the original's aspect
ratio, filling the entire bounding box).
'fit_longest': scale the pattern so that its longest dimension is
made to fill the corresponding dimension on a Sheet with
bounds=BoundingBox(radius=0.5) (maintains the original's
aspect ratio, fitting the image into the bounding box but not
necessarily filling it).
'original': no scaling is applied; each pixel of the pattern
corresponds to one matrix unit of the Sheet on which the
pattern being displayed.""")
def _get_image(self):
return self.scs.activity
def _set_image(self,image):
# Stores a SheetCoordinateSystem with an activity matrix
# representing the image
if not isinstance(image,np.ndarray):
image = np.array(image,np.float)
rows,cols = image.shape
self.scs = SheetCoordinateSystem(xdensity=1.0,ydensity=1.0,
bounds=BoundingBox(points=((-cols/2.0,-rows/2.0),
( cols/2.0, rows/2.0))))
self.scs.activity=image
def _del_image(self):
self.scs = None
def __call__(self, image, x, y, sheet_xdensity, sheet_ydensity, width=1.0, height=1.0):
"""
Return pixels from the supplied image at the given Sheet (x,y)
coordinates.
The image is assumed to be a NumPy array or other object that
exports the NumPy buffer interface (i.e. can be converted to a
NumPy array by passing it to numpy.array(), e.g. Image.Image).
The whole_pattern_output_fns are applied to the image before
any sampling is done.
To calculate the sample, the image is scaled according to the
size_normalization parameter, and any supplied width and
height. sheet_xdensity and sheet_ydensity are the xdensity and
ydensity of the sheet on which the pattern is to be drawn.
"""
# CEB: could allow image=None in args and have 'if image is
# not None: self.image=image' here to avoid re-initializing the
# image.
self.image=image
for wpof in self.whole_pattern_output_fns:
wpof(self.image)
if not self.background_value_fn:
self.background_value = 0.0
else:
self.background_value = self.background_value_fn(self.image)
pattern_rows,pattern_cols = self.image.shape
if width==0 or height==0 or pattern_cols==0 or pattern_rows==0:
return np.ones(x.shape)*self.background_value
# scale the supplied coordinates to match the pattern being at density=1
x=x*sheet_xdensity # deliberately don't operate in place (so as not to change supplied x & y)
y=y*sheet_ydensity
# scale according to initial pattern size_normalization selected (size_normalization)
self.__apply_size_normalization(x,y,sheet_xdensity,sheet_ydensity,self.size_normalization)
# scale according to user-specified width and height
x/=width
y/=height
# now sample pattern at the (r,c) corresponding to the supplied (x,y)
r,c = self.scs.sheet2matrixidx(x,y)
# (where(cond,x,y) evaluates x whether cond is True or False)
r.clip(0,pattern_rows-1,out=r)
c.clip(0,pattern_cols-1,out=c)
left,bottom,right,top = self.scs.bounds.lbrt()
return np.where((x>=left) & (x<right) & (y>bottom) & (y<=top),
self.image[r,c],
self.background_value)
def __apply_size_normalization(self,x,y,sheet_xdensity,sheet_ydensity,size_normalization):
pattern_rows,pattern_cols = self.image.shape
# Instead of an if-test, could have a class of this type of
# function (c.f. OutputFunctions, etc)...
if size_normalization=='original':
return
elif size_normalization=='stretch_to_fit':
x_sf,y_sf = pattern_cols/sheet_xdensity, pattern_rows/sheet_ydensity
x*=x_sf; y*=y_sf
elif size_normalization=='fit_shortest':
if pattern_rows<pattern_cols:
sf = pattern_rows/sheet_ydensity
else:
sf = pattern_cols/sheet_xdensity
x*=sf;y*=sf
elif size_normalization=='fit_longest':
if pattern_rows<pattern_cols:
sf = pattern_cols/sheet_xdensity
else:
sf = pattern_rows/sheet_ydensity
x*=sf;y*=sf
