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
