def __init__(self, start_points_generator = lpcRandomStartPoints(), **params): ''' Arguments --------- start_points_generator: a type callable with a single argument, x0, also implements the function setScaleParameters(h) (see doc for function self.resetScaleParameters) h : 1-dim numpy.array, length m or float, bandwidth. May be either specified as a single number, then the same bandwidth is used in all dimensions, or as an m-dimensional bandwidth vector (where m is the dimension of feature points). The default setting is 10 percent of the range in each direction. If scaled =TRUE then, if specified, the bandwidth has to be specified in fractions of the data range, e.g. h = [0.2, 0.1, 0.3], rather than absolute values. t0 : float, scalar step length. Default setting is 't0 = h' if 'h' is a scalar, and 't0 = mean(h)' if 'h' is a vector. depth (NOT USED): int, maximum depth of branches, restricted to the values 1,2 or 3 (The original LPC branch has depth 1. If, along this curve, a point features a high second local PC, this launches a new starting point, and the resulting branch has depth 2. If, along this branch, a point features a high second local PC, this launches a new starting point, and the resulting branch has depth 3. ) way: "one": go only in direction of the first local eigenvector, "back": go only in opposite direction, "two": go from starting point in both directions. scaled: bool, if True, scales each variable by dividing through its range pen: power used for angle penalization. If set to 0, the angle penalization is switched off. it : maximum number of iterations on either side of the starting point within each branch. cross: If True, curves are stopped when they come too close to an existing branch. Used in the self-coverage function. boundary: This boundary correction [2] reduces the bandwidth adaptively once the relative difference of parameter values between two centers of mass falls below the given threshold. This measure delays convergence and enables the curve to proceed further into the end points. If set to 0, this boundary correction is switched off. convergence_at: this forces the curve to stop if the relative difference of parameter values between two centers of mass falls below the given threshold. If set to 0, then the curve will always stop after exactly "iter" iterations. mult: integer which enforces a fixed number of starting points. If the number given here is larger than the number of starting points provided at "x0", then the missing points will be set at random (For example, if d=2, mult=3, and x0=c(58.5, 17.8, 80,20), then one gets the starting points (58.5, 17.8), (80,20), and a randomly chosen third one. Another example for such a situation is "x0=NULL" with "mult=1", in which one random starting point is chosen). If the number given here is smaller the number of starting points provided at x0, then only the first "mult" starting points will be used. pruning_thresh (NOT USED) : float, used to remove non-dense, depth > 1 branches rho0: float, steers the birth process of higher-depth starting points by acting as a threshold for definition of high_rho_pts. Usually, between 0.3 and 0.4 gapsize (NOT USED): float, sets scaling of t0 which is applied when starting depth > 1 branches binary: If True, weights supplied to self.lpc are ignored and each point has equal weight in calculation of the lpc curve. (Default: True) ''' super(LPCImpl, self).__init__() self._lpcParameters = { 'h': None, 't0': None, 'way': 'two', 'scaled': True, 'pen': 2, 'depth': 1, 'it': 100, 'cross': True, 'boundary': 0.005, 'convergence_at': 1e-6, 'mult': None, #set this to None to allow exactly the number of local density modes to be returned from MeanShift 'pruning_thresh': 0.0, 'rho0': 0.4, 'gapsize': 1.5, 'binary': True } self._prm_list = [self._lpcParameters] self.user_prm = None #extension of parameter set disallowed self._type_check.update({ 'h': lambda x: (x == None) or LPCImpl._positivityCheck(x) or (isinstance(x, list) and all(map(LPCImpl._positivityCheck, x)) ) , 't0': lambda x: (x == None) or LPCImpl._positivityCheck, 'way': lambda x: x in ('one', 'two', 'back'), 'scaled': (bool,), 'pen': lambda x: (x == 0) or LPCImpl._positivityCheck, 'depth': lambda x: x in (1,2,3), 'it': lambda x: isinstance(x, int) and x > 9, 'cross': (bool,), 'convergence_at': LPCImpl._positivityCheck, 'boundary': lambda x: LPCImpl._positivityCheck(x), #TODO - no assertion boundary > convergence.at (add to _update) 'mult': lambda x: (x == None) or (isinstance(x, int) and x > 0), 'pruning_thresh': LPCImpl._positivityCheck, 'rho0': LPCImpl._positivityCheck, 'gapsize': LPCImpl._positivityCheck, 'binary': (bool,) }) self.set(**params) self.Xi = None self.x0 = None #set equal to the return value of _selectStartPoints self._dataRange = None self._weights = None self._curve = None if not iscallable(start_points_generator): raise TypeError, 'Start points generator must be callable' self._startPointsGenerator = start_points_generator
def testlpcRandomStartPoints1(self): print 'Generate 1 random start point from line, with no explicitly defined start points' lpcRSP = lpcRandomStartPoints() sp = lpcRSP(self._line, 1) print sp