def __init__(self, noiseLevel=0.0, doForeground=True, doBackground=False, dynamic=True, noiseThickness=1): """ noiseLevel -- Amount of noise to add, from 0 to 1.0. For black and white images, this means the values of noiseLevel fraction of the pixels will be flipped (e.g. noiseLevel of 0.2 flips 20 percent of the pixels). For grayscale images, each pixel will be modified by up to 255 * noiseLevel (either upwards or downwards). doForeground -- Whether to add noise to the foreground. For black and white images, black pixels are foreground and white pixels are background. For grayscale images, any pixel which does not equal the background color (the ImageSensor 'background' parameter) is foreground, and the rest is background. doBackground -- Whether to add noise to the background (see above). """ BaseFilter.__init__(self) self.noiseLevel = noiseLevel self.doForeground = doForeground self.doBackground = doBackground self.dynamic = dynamic self.noiseThickness = noiseThickness # Generate and save our random state saveState = numpy.random.get_state() numpy.random.seed(0) self._randomState = numpy.random.get_state() numpy.random.set_state(saveState)
def __init__(self, factor=1.0, scaleTowardCenter=False): """ Parameters ---------- factor: float How much contrast to produce in the output image relative to the input image. A factor of 0 returns a solid gray image, a factor of 1.0 returns the original image, and higher values return higher-contrast images. scaleTowardCenter: bool If False (the default), uses PIL.ImageEnhance.Contrast. If True, scales the pixel values toward 0.5. """ BaseFilter.__init__(self) if factor < 0: raise ValueError("'factor' must be nonnegative") self.factor = factor self.scaleTowardCenter = scaleTowardCenter if scaleTowardCenter and not (0.0 <= factor <= 1.0): raise ValueError("scaleTowardCenter only supports contrast factors " "between 0 and 1, inclusive.")
def __init__(self, angles=[0], expand=False, targetRatio=None, highQuality=True): """ angles -- List of angles by which to rotate, in degrees. expand -- Whether to expand the output image to contain the entire rotated image. If False, the output image will match the dimensions of the input image, but cropping may occur. targetRatio -- Ratio of the sensor. If specified, used if expand == False to grow the image to the target ratio to avoid unnecessary clipping. highQuality -- Whether to use bicubic interpolation for rotating. instead of nearest neighbor. """ BaseFilter.__init__(self) self.angles = angles self.expand = expand self.targetRatio = targetRatio self.highQuality = highQuality if not expand: for i, angle in enumerate(angles): if angle != 0 and angle % 90 == 0: angles[i] -= .01 # Oh, PIL...
def __init__(self, xsize, ysize, c, preserveCenterResolution=False, Debug=False): """ Initializes the kernel matrices, a one-time cost, which are then applied to each image. @param xsize -- The x-dimension size of the desired output @param ysize -- The y-dimension size of the desired output @param c -- Paramaterizes how much the image bends (ie. how steep the fish-eye. c=0 is no distortion. c=3 is severe. @param preserveCenterResolution -- if True, the resolution of the center of the image will be preserved and the edges will be sub-sampled. If False, the center pixels will be blown up to keep the outside corners at the original resolution. @param Debug -- Determines whether to compute and save some intermediate data structures for debugging (deltaxmat, deltaymat, scales). """ BaseFilter.__init__(self) # Init params self._lastOutputImage = None self._xsize = xsize self._ysize = ysize self._c = c self._pcr = preserveCenterResolution self._debug = Debug self._kernelx = None self._kernely = None self._kernel = None self._imgSize = (-1,-1)
def __init__(self, xsize, ysize, c, preserveCenterResolution=False, Debug=False): """ Initializes the kernel matrices, a one-time cost, which are then applied to each image. @param xsize -- The x-dimension size of the desired output @param ysize -- The y-dimension size of the desired output @param c -- Paramaterizes how much the image bends (ie. how steep the fish-eye. c=0 is no distortion. c=3 is severe. @param preserveCenterResolution -- if True, the resolution of the center of the image will be preserved and the edges will be sub-sampled. If False, the center pixels will be blown up to keep the outside corners at the original resolution. @param Debug -- Determines whether to compute and save some intermediate data structures for debugging (deltaxmat, deltaymat, scales). """ BaseFilter.__init__(self) # Init params self._lastOutputImage = None self._xsize = xsize self._ysize = ysize self._c = c self._pcr = preserveCenterResolution self._debug = Debug self._kernelx = None self._kernely = None self._kernel = None self._imgSize = (-1, -1)
def __init__(self, shiftSize=1): """ @param stepSize -- number of pixels to shift """ BaseFilter.__init__(self) self.shiftSize = shiftSize
def __init__(self, level=1): """ @param level -- Number of times to blur. """ BaseFilter.__init__(self) self.level = level
def __init__(self, difficulty = 0.5, seed=None, reproducible=False): """ @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible)
def __init__(self, difficulty=0.5, seed=None, reproducible=False): """ @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible)
def __init__(self, width, height): """ ** DEPRECATED ** @param width -- Target width, in pixels. @param height -- Target height, in pixels. """ BaseFilter.__init__(self) self.width = width self.height = height
def __init__(self, seed=None, reproducible=False, both=False): """ @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. both -- Whether to also pass through the original image. """ BaseFilter.__init__(self, seed, reproducible) self.both = both
def __init__(self, box): """ @param box -- 4-tuple specifying the left, top, right, and bottom coords. """ BaseFilter.__init__(self) if box[2] <= box[0] or box[3] <= box[1]: raise RuntimeError('Specified box has zero width or height') self.box = box
def __init__(self, factor=1.0): """ @param factor -- Factor by which to brighten the image, a nonnegative number. 0.0 returns a black image, 1.0 returns the original image, and higher values return brighter images. """ BaseFilter.__init__(self) if factor < 0: raise ValueError("'factor' must be a nonnegative number") self.factor = factor
def __init__(self, difficulty = 0.5, seed=None, reproducible=False): """ @param difficulty -- Value between 0.0 and 1.0 that controls the intensity of the gradient applied. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.difficulty = difficulty self.types = ('horizontal', 'vertical', 'circular') self.gradientImages = {}
def __init__(self, difficulty = 0.5, seed=None, reproducible=False): """ @param difficulty -- Value between 0.0 and 1.0 that controls how many lines to add in image. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.difficulty = difficulty #Maximum number of lines to add self.maxLines = 10
def __init__(self, numRectangles=4, seed=None, reproducible=False): """ @param numRectangles -- Number of rectangles to add. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.numRectangles = numRectangles
def __init__(self, difficulty=0.5, seed=None, reproducible=False): """ @param difficulty -- Value between 0.0 and 1.0 that controls how many lines to add in image. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.difficulty = difficulty #Maximum number of lines to add self.maxLines = 10
def __init__(self, difficulty=0.5, seed=None, reproducible=False): """ @param difficulty -- Value between 0.0 and 1.0 that controls the intensity of the gradient applied. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.difficulty = difficulty self.types = ('horizontal', 'vertical', 'circular') self.gradientImages = {}
def __init__(self, scales=[1], simultaneous=False): """ ** DEPRECATED ** @param scales -- List of factors used for scaling. scales = [.5, 1] returns two images, one half the size of the original in each dimension, and one which is the original image. @param simultaneous -- Whether the images should be sent out of the sensor simultaneously. """ BaseFilter.__init__(self) self.scales = scales self.simultaneous = simultaneous
def __init__(self, img=None, threshold=10, maskScale=1.0, blurRadius=0.0): """ @param img -- path to background image(s) to use """ BaseFilter.__init__(self) self.bgPath = img self.bgImgs = None self._rng = random.Random() self._rng.seed(42) self._threshold = threshold self._maskScale = maskScale self._blurRadius = blurRadius
def __init__(self, difficulty=0.5, seed=None, reproducible=False): """ @param difficulty -- Controls the amount of stretch and shear applied to the image. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.difficulty = difficulty self.maxShear = 1.0 self.maxSqueeze = 0.1 self.minSqueeze = 1.0 self.types = ('shear_x', 'shear_y', 'squeeze_x', 'squeeze_y')
def __init__(self, difficulty = 0.5, seed=None, reproducible=False): """ @param difficulty -- Controls the amount of stretch and shear applied to the image. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) self.difficulty = difficulty self.maxShear = 1.0 self.maxSqueeze = 0.1 self.minSqueeze = 1.0 self.types = ('shear_x', 'shear_y', 'squeeze_x', 'squeeze_y')
def __init__(self, width, height, scaleHeightTo=None, scaleWidthTo=None, pad=False): """ ** DEPRECATED ** @param width -- Target width, in pixels. @param height -- Target height, in pixels. @param pad -- Whether to pad the image with the background color in order to fit the specified size exactly. """ BaseFilter.__init__(self) self.width = width self.height = height self.pad = pad self.scaleHeightTo = scaleHeightTo self.scaleWidthTo = scaleWidthTo
def __init__(self, value=None, threshold=10, maskScale=1.0, blurRadius=0.0): """ @param value -- If None, the background is filled in with the background color. Otherwise, it is filled with value. If value is a list, then this filter will return multiple images, one for each value """ BaseFilter.__init__(self) if hasattr(value, '__len__'): self._values = value else: self._values = [value] self._threshold = threshold self._maskScale = maskScale self._blurRadius = blurRadius
def __init__( self, targetDims, padding=0, scales=None, fillValue=0, fillFromImageWherePossible=True, preservationMode=None, qualityLevel="antialias", dumpDebugImages=False, applyAlpha=True, ): """ @param qualityLevel -- specifies the quality of the filter to be used for resizing image patches; must be one of: 'nearest', 'bilinear', 'bicubic', 'antialias' (in increasing order of quality) @param applyAlpha -- if True, we'll "apply" the alpha channel to the image before flattening it (from 'LA' to 'L'). This allows you to pass in images that are non-rectangular. If False, the alpha channel will just be used to figure out the bounding box of the object (unless a tracking box is passed in, in which case alpha is ignored). Note: this is only useful if fillFromImageWherePossible=False """ BaseFilter.__init__(self) # Apply default for scales if scales is None: scales = [1.0] if type(scales) not in (list, tuple): raise ValueError("'scales' must be a list or tuple") if type(scales) is tuple: scales = list(scales) self._applyAlpha = applyAlpha self._targetDims = targetDims self._padding = padding self._scales = scales self._fillValue = fillValue self._fillFromImageWherePossible = fillFromImageWherePossible self._preservationMode = preservationMode self._resizingFilter = eval("Image.%s" % qualityLevel.upper()) self._dumpDebugImages = dumpDebugImages if fillValue is None: self._histWeights = numpy.array(range(256), dtype="float")
def __init__(self, region="all", mode=None): """ @param region -- Options are 'all' (equalize the entire image), 'bbox' (equalize just the portion of the image within the bounding box), and 'mask' (equalize just the portion of the image within the mask). @param mode -- ** DEPRECATED ** Alias for 'region'. """ BaseFilter.__init__(self) if mode is not None: region = mode if region not in ("all", "bbox", "mask"): raise RuntimeError("Not a supported region (options are 'all', 'bbox', and 'mask')") self.region = region
def __init__(self, difficulty = 0.5, seed=None, reproducible=False): """ @param difficulty -- Value between 0.0 and 1.0 that dictates how far to shift the image histogram. The direction will be random, and a random offset will be added. @param seed -- Seed value for random number generator, to produce reproducible results. @param reproducible -- Whether to seed the random number generator based on a hash of the image pixels upon each call to process(). 'seed' and 'reproducible' cannot be used together. """ BaseFilter.__init__(self, seed, reproducible) if difficulty < 0.0 or difficulty > 1.0: raise RuntimeError("difficulty must be between 0.0 and 1.0") self.difficulty = difficulty #Maximum histogram shift - half the grayscale band (0-255) self.maxOffset = 128
def __init__(self, targetDims, padding=0, scales=None, fillValue=0, fillFromImageWherePossible=True, preservationMode=None, qualityLevel='antialias', dumpDebugImages=False, applyAlpha=True): """ @param qualityLevel -- specifies the quality of the filter to be used for resizing image patches; must be one of: 'nearest', 'bilinear', 'bicubic', 'antialias' (in increasing order of quality) @param applyAlpha -- if True, we'll "apply" the alpha channel to the image before flattening it (from 'LA' to 'L'). This allows you to pass in images that are non-rectangular. If False, the alpha channel will just be used to figure out the bounding box of the object (unless a tracking box is passed in, in which case alpha is ignored). Note: this is only useful if fillFromImageWherePossible=False """ BaseFilter.__init__(self) # Apply default for scales if scales is None: scales = [1.0] if type(scales) not in (list, tuple): raise ValueError("'scales' must be a list or tuple") if type(scales) is tuple: scales = list(scales) self._applyAlpha = applyAlpha self._targetDims = targetDims self._padding = padding self._scales = scales self._fillValue = fillValue self._fillFromImageWherePossible = fillFromImageWherePossible self._preservationMode = preservationMode self._resizingFilter = eval("Image.%s" % qualityLevel.upper()) self._dumpDebugImages = dumpDebugImages if fillValue is None: self._histWeights = numpy.array(range(256), dtype='float')
def __init__(self, region='all', mode=None): """ @param region -- Options are 'all' (equalize the entire image), 'bbox' (equalize just the portion of the image within the bounding box), and 'mask' (equalize just the portion of the image within the mask). @param mode -- ** DEPRECATED ** Alias for 'region'. """ BaseFilter.__init__(self) if mode is not None: region = mode if region not in ('all', 'bbox', 'mask'): raise RuntimeError( "Not a supported region (options are 'all', 'bbox', and 'mask')") self.region = region
def __init__(self, region='all', mode=None, cutoff=0): """ @param region -- Options are 'all' (equalize the entire image), 'bbox' (equalize just the portion of the image within the bounding box), and 'mask' (equalize just the portion of the image within the mask). @param mode -- ** DEPRECATED ** Alias for 'region'. @param cutoff -- Number of pixels to clip from each end of the histogram before rescaling it. """ BaseFilter.__init__(self) if mode is not None: region = mode if region not in ('all', 'bbox', 'mask'): raise RuntimeError( "Not a supported region (options are 'all', 'bbox', and 'mask')") if type(cutoff) != int or cutoff < 0: raise RuntimeError("'cutoff' must be a positive integer") self.region = region self.cutoff = cutoff
def __init__(self, size=None, sizes=None, method='fit', simultaneous=False, highQuality=False): """ size -- Target size. Either a tuple (width, height), specifying an absolute size in pixels, or a single value, specifying a scale factor to apply to the current size. sizes -- List of target sizes, for creating multiple output images for each input image. Each entry in the list must satisfy the requirements for the 'size' parameter, above. 'size' and 'sizes' may not be used together. method -- Method to use for generating new images, one of: 'fit' : scale and pad to match new size, preserving aspect ratio 'crop' : scale and crop the image to fill the new size 'stretch' : stretch the image to fill new size, ignoring aspect ratio 'center' : center the original image in the new size without scaling simultaneous -- Whether the images should be sent out of the sensor simultaneously. highQuality -- Whether to use high-quality sampling for resizing instead of nearest neighbor. If highQuality is True, antialiasing is used for downsampling and bicubic interpolation is used for upsampling. Example usage: Resize the incoming image to fit within (320, 240) by scaling so that the image fits exactly within (320, 240) but the aspect ratio is maintained, and padding with the sensor's background color: Resize(size=(320, 240)) Scale the image to three different sizes: 100% of the original size, 50% of the original size, and 25% of the original size, and send the three images out of the sensor simultaneously as multiple scales: Resize(sizes=(1.0, 0.5, 0.25), simultaneous=True) Pad the image to fit in a larger image of size (640, 480), centering it in the new image: Resize(size=(640, 480), method='center') """ BaseFilter.__init__(self) if (not size and not sizes) or (size and sizes): raise RuntimeError("Must specify either 'size' or 'sizes'") if size: sizes = [size] if type(sizes) not in (list, tuple): raise ValueError("Sizes must be a list or tuple") if type(sizes) is tuple: sizes = list(sizes) for i, size in enumerate(sizes): if type(size) in (list, tuple): if len(size) > 2: raise ValueError( "Size is too long (must be a scalar or 2-tuple)") elif type(size) in (int, float): if size <= 0: raise ValueError("Sizes must be positive numbers") sizes[i] = [size] else: raise TypeError("Sizes must be positive numbers") if method not in ('fit', 'crop', 'stretch', 'center'): raise ValueError( "Unknown method " "(options are 'fit', 'crop', 'stretch', and 'center')") self.sizes = sizes self.method = method self.simultaneous = simultaneous self.highQuality = highQuality
def __init__(self, scaleDecimation=[1], filterDim=9, gainConstant=1.0, normalizationMethod='fixed', perPlaneNormalization=False, perPhaseNormalization=True, postProcessingMethod='raw', postProcessingSlope=1.0, postProcessingCenter=0.5, postProcessingMin=0.0, postProcessingMax=1.0, zeroThresholdOut=0.0, boundaryMode='constrained', offImagePixelValue=0, suppressOutsideBox=True, forceBoxContraction=False, aspectRatio=0.3, effectiveWidth=4.5): """Initialize the the convolution filter @param inputDims: a list of input image sizes in the form of 2-tuples (width, height) """ BaseFilter.__init__(self) self._scaleDecimation = scaleDecimation self._filterDim = filterDim self._gainConstant = gainConstant self._normalizationMethod = normalizationMethod self._perPlaneNormalization = perPlaneNormalization self._perPhaseNormalization = perPhaseNormalization self._postProcessingMethod = postProcessingMethod self._postProcessingSlope = postProcessingSlope self._postProcessingCenter = postProcessingCenter self._postProcessingMin = postProcessingMin self._postProcessingMax = postProcessingMax self._zeroThresholdOut = zeroThresholdOut self._boundaryMode = boundaryMode self._offImagePixelValue = offImagePixelValue self._suppressOutsideBox = suppressOutsideBox self._forceBoxContraction = forceBoxContraction self._aspectRatio = aspectRatio self._effectiveWidth = effectiveWidth self._filterBank = None self._outputPlaneCount = self._calcPlaneCount() self._cache = {} self._bbox_cache = {} # Load the _algorithms C library that contains the fast convolution code libAlgorithms = self._loadLibrary("_algorithms") # Prepare the C calls self._convolutionProc = libAlgorithms.gaborCompute # Generate post-processing lookup-tables (LUTs) that will be # used by the C implementation self._makeLUTs()
def __init__(self, #-------------------------------------------------- # General parameters # # Width (in pixels) of smooth window for horizontal # SMotion strength histogram windowX=9, # Height (in pixels) of smooth window for vertical # SMotion strength histogram windowY=9, # Smooth window type; must be one of: 'flat', 'hanning', # 'hamming', 'bartlett', 'blackman' windowType='hanning', #-------------------------------------------------- # Horizontal tightening/splitting parameters # # Minimum smoothed SMotion strength (summed vertically) # for an X position to be considered "strong" (expressed as # a fraction of the maximum vertically-summed SMotion) heightThresh=0.1, # Minimum peak SMotion strength for a secondary lobe # (i.e., not the strongest "primary" lobe) to avoid # being culled secondaryHeightThresh=0.5, # Minimum absolute horizontal length (in pixels) that a # horizontal strong zone must extend to avoid being # culled minAbsZoneLenX=5, # Minimum relative horizontal length (expressed as a # fraction of the total original box width) that a # horizontal strong zone must extend to avoid being # culled minRelZoneLenX=0.15, # Minimum horizontal "gap" width (in terms of absolute # pixels) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minAbsWeakLenX=5, # Minimum horizontal "gap" width (as percentage of the # image width) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minRelWeakLenX=0.10, # The number of pixels to expand our accepted zones # horizontally prior to tightening/splitting zonePreExpansionX=16, #8, #0, #8, # The number of pixels to expand our accepted zones # norizontally following tightening/splitting zonePostExpansionX=4, #0, #4, #-------------------------------------------------- # Vertical tightening/splitting parameters # # Minimum smoothed SMotion strength (summed horizontally) # for a Y position to be considered "strong" (expressed as # a fraction of the maximum horizontally-summed SMotion) widthThresh=0.1, # Minimum peak SMotion strength for a secondary lobe # (i.e., not the strongest "primary" lobe) to avoid # being culled secondaryWidthThresh=0.20, # Minimum absolute vertical length (in pixels) that a # vertical strong zone must extend to avoid being # culled minAbsZoneLenY=5, # Minimum relative vertical length (expressed as a # fraction of the total original box height) that a # vertical strong zone must extend to avoid being # culled minRelZoneLenY=0.15, # Minimum vertical "gap" width (in terms of absolute # pixels) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minAbsWeakLenY=5, # Minimum vertical "gap" width (as percentage of the # image height) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minRelWeakLenY=0.30, # The number of pixels to expand our accepted zones # vertically (not yet implemented) zonePreExpansionY=16, #8, #0, #8, # The number of pixels to expand our accepted zones # vertically following tightening/splitting zonePostExpansionY=4, #0, #4, #--------------------------------- # Splitting policy # Controls what to do if our algorithm wants to split # a box. Valid values are 'union' (take the union of # the split pieces) or 'biggest' (use the biggest # split box.) splitPolicy='biggest', #--------------------------------- # Debugging debugMode=False, ): """ """ BaseFilter.__init__(self) self._windowX = windowX self._windowY = windowY self._windowType = windowType self._heightThresh = heightThresh self._secondaryHeightThresh = secondaryHeightThresh self._minAbsZoneLenX = minAbsZoneLenX self._minRelZoneLenX = minRelZoneLenX self._minAbsWeakLenX = minAbsWeakLenX self._minRelWeakLenX = minRelWeakLenX self._zonePreExpansionX = zonePreExpansionX self._zonePostExpansionX = zonePostExpansionX self._widthThresh = widthThresh self._secondaryWidthThresh = secondaryWidthThresh self._minAbsZoneLenY = minAbsZoneLenY self._minRelZoneLenY = minRelZoneLenY self._minAbsWeakLenY = minAbsWeakLenY self._minRelWeakLenY = minRelWeakLenY self._zonePreExpansionY = zonePreExpansionY self._zonePostExpansionY = zonePostExpansionY self._splitPolicy = splitPolicy self._debugMode = debugMode # Counts how many images we've processed self._imgCounter = 0
def __init__( self, #-------------------------------------------------- # General parameters # # Width (in pixels) of smooth window for horizontal # SMotion strength histogram windowX=9, # Height (in pixels) of smooth window for vertical # SMotion strength histogram windowY=9, # Smooth window type; must be one of: 'flat', 'hanning', # 'hamming', 'bartlett', 'blackman' windowType='hanning', #-------------------------------------------------- # Horizontal tightening/splitting parameters # # Minimum smoothed SMotion strength (summed vertically) # for an X position to be considered "strong" (expressed as # a fraction of the maximum vertically-summed SMotion) heightThresh=0.1, # Minimum peak SMotion strength for a secondary lobe # (i.e., not the strongest "primary" lobe) to avoid # being culled secondaryHeightThresh=0.5, # Minimum absolute horizontal length (in pixels) that a # horizontal strong zone must extend to avoid being # culled minAbsZoneLenX=5, # Minimum relative horizontal length (expressed as a # fraction of the total original box width) that a # horizontal strong zone must extend to avoid being # culled minRelZoneLenX=0.15, # Minimum horizontal "gap" width (in terms of absolute # pixels) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minAbsWeakLenX=5, # Minimum horizontal "gap" width (as percentage of the # image width) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minRelWeakLenX=0.10, # The number of pixels to expand our accepted zones # horizontally prior to tightening/splitting zonePreExpansionX=16, #8, #0, #8, # The number of pixels to expand our accepted zones # norizontally following tightening/splitting zonePostExpansionX=4, #0, #4, #-------------------------------------------------- # Vertical tightening/splitting parameters # # Minimum smoothed SMotion strength (summed horizontally) # for a Y position to be considered "strong" (expressed as # a fraction of the maximum horizontally-summed SMotion) widthThresh=0.1, # Minimum peak SMotion strength for a secondary lobe # (i.e., not the strongest "primary" lobe) to avoid # being culled secondaryWidthThresh=0.20, # Minimum absolute vertical length (in pixels) that a # vertical strong zone must extend to avoid being # culled minAbsZoneLenY=5, # Minimum relative vertical length (expressed as a # fraction of the total original box height) that a # vertical strong zone must extend to avoid being # culled minRelZoneLenY=0.15, # Minimum vertical "gap" width (in terms of absolute # pixels) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minAbsWeakLenY=5, # Minimum vertical "gap" width (as percentage of the # image height) which a weak zone must extend to avoid # being filled in (if it lies between two strong zones) minRelWeakLenY=0.30, # The number of pixels to expand our accepted zones # vertically (not yet implemented) zonePreExpansionY=16, #8, #0, #8, # The number of pixels to expand our accepted zones # vertically following tightening/splitting zonePostExpansionY=4, #0, #4, #--------------------------------- # Splitting policy # Controls what to do if our algorithm wants to split # a box. Valid values are 'union' (take the union of # the split pieces) or 'biggest' (use the biggest # split box.) splitPolicy='biggest', #--------------------------------- # Debugging debugMode=False, ): """ """ BaseFilter.__init__(self) self._windowX = windowX self._windowY = windowY self._windowType = windowType self._heightThresh = heightThresh self._secondaryHeightThresh = secondaryHeightThresh self._minAbsZoneLenX = minAbsZoneLenX self._minRelZoneLenX = minRelZoneLenX self._minAbsWeakLenX = minAbsWeakLenX self._minRelWeakLenX = minRelWeakLenX self._zonePreExpansionX = zonePreExpansionX self._zonePostExpansionX = zonePostExpansionX self._widthThresh = widthThresh self._secondaryWidthThresh = secondaryWidthThresh self._minAbsZoneLenY = minAbsZoneLenY self._minRelZoneLenY = minRelZoneLenY self._minAbsWeakLenY = minAbsWeakLenY self._minRelWeakLenY = minRelWeakLenY self._zonePreExpansionY = zonePreExpansionY self._zonePostExpansionY = zonePostExpansionY self._splitPolicy = splitPolicy self._debugMode = debugMode # Counts how many images we've processed self._imgCounter = 0
def __init__(self, size=None, sizes=None, method='fit', simultaneous=False, highQuality=False): """ size -- Target size. Either a tuple (width, height), specifying an absolute size in pixels, or a single value, specifying a scale factor to apply to the current size. sizes -- List of target sizes, for creating multiple output images for each input image. Each entry in the list must satisfy the requirements for the 'size' parameter, above. 'size' and 'sizes' may not be used together. method -- Method to use for generating new images, one of: 'fit' : scale and pad to match new size, preserving aspect ratio 'crop' : scale and crop the image to fill the new size 'stretch' : stretch the image to fill new size, ignoring aspect ratio 'center' : center the original image in the new size without scaling simultaneous -- Whether the images should be sent out of the sensor simultaneously. highQuality -- Whether to use high-quality sampling for resizing instead of nearest neighbor. If highQuality is True, antialiasing is used for downsampling and bicubic interpolation is used for upsampling. Example usage: Resize the incoming image to fit within (320, 240) by scaling so that the image fits exactly within (320, 240) but the aspect ratio is maintained, and padding with the sensor's background color: Resize(size=(320, 240)) Scale the image to three different sizes: 100% of the original size, 50% of the original size, and 25% of the original size, and send the three images out of the sensor simultaneously as multiple scales: Resize(sizes=(1.0, 0.5, 0.25), simultaneous=True) Pad the image to fit in a larger image of size (640, 480), centering it in the new image: Resize(size=(640, 480), method='center') """ BaseFilter.__init__(self) if (not size and not sizes) or (size and sizes): raise RuntimeError("Must specify either 'size' or 'sizes'") if size: sizes = [size] if type(sizes) not in (list, tuple): raise ValueError("Sizes must be a list or tuple") if type(sizes) is tuple: sizes = list(sizes) for i, size in enumerate(sizes): if type(size) in (list, tuple): if len(size) > 2: raise ValueError("Size is too long (must be a scalar or 2-tuple)") elif type(size) in (int, float): if size <= 0: raise ValueError("Sizes must be positive numbers") sizes[i] = [size] else: raise TypeError("Sizes must be positive numbers") if method not in ('fit', 'crop', 'stretch', 'center'): raise ValueError("Unknown method " "(options are 'fit', 'crop', 'stretch', and 'center')") self.sizes = sizes self.method = method self.simultaneous = simultaneous self.highQuality = highQuality