def accumulate(self, points, acc): acc.fill(0) for (x, y) in points: if not (np.isfinite(x) and np.isfinite(y)): continue r = np.linalg.norm([x, y]) ix_r, ix_t = self.hough(x, y, self.theta_, s=self.sin_, c=self.cos_) ix_r *= (self.n_r_ / self.mx_r_) ix_t *= (self.n_t_ / self.mx_t_) # convert to index ix_r = U.rint(ix_r) ix_t = U.rint(ix_t) # filter by max radius sel = (ix_r < self.n_r_) ix_r = ix_r[sel] ix_t = ix_t[sel] try: # weighted addition based on radius # TODO : is this a better method? np.add.at(acc, (ix_r, ix_t), r) except Exception as e: print x print y raise e
def _solve(M, N, strict_nonblocking=False): if strict_nonblocking: target = partial(_get_links_strict, M, N) else: target = partial(_get_links_rearrangeable, M, N) mid = (M * N * 1. / (M + N))**.5 b0 = .5 * min(M, N)**.5 b1 = 2. * max(M, N)**.5 n1, n2 = opt.minimize(target, (mid, mid), bounds=((b0, b1), (b0, b1))).x # print "%.3f %.3f" % (n1, n2) n1 = rint(n1) n2 = rint(n2) return n1, n2
def convert_to_bin_idx(self, grid_idx): bin_idx = utils.rint(np.sum(grid_idx * self._modulus)) if bin_idx >= self.nbins or bin_idx < 0: raise Exception( "Invalid bin index %s. You are probably outside the grid. Size:%s" % (bin_idx, self.nbins)) return bin_idx
def _create_beta1_targetedmd(): cvs_dir = "../../gpcr/cvs/beta1-cvs/" beta1_cvs = load_object(cvs_dir + "cvs") create_targetmd_input( beta1_cvs, np.loadtxt(cvs_dir + "string-paths/string0_beta1_inactive_endpoint.txt"), steps_per_point=utils.rint(3000000 / 22), backwards=True)
def create_default_mapping(self, previous_stringpath, stringpath, fixed_endpoints): mapping = np.zeros((len(stringpath), 3)) - 1 point_ratio = len(previous_stringpath) / len(stringpath) if fixed_endpoints: mapping[0, 0] = 0 mapping[-1, 0] = len(previous_stringpath) - 1 for point_idx in range(len(mapping)): if fixed_endpoints and (point_idx == 0 or point_idx == len(stringpath) - 1): continue previous_idx = utils.rint(point_idx * point_ratio) mapping[point_idx, 0] = previous_idx return mapping
def _create_beta2_targetedmd(): time_ns = 10 kappa = 10000.0 topology = md.load( utils.project_dir + "gpcr/reference_structures/3p0g/asp79-apo/equilibrated.gro").topology cvs = colvars.cvs_definition_reader.load_cvs(cvs_len5path + "cvs.json") plumed_file_content = colvars.plumed_tools.convert_to_plumed_restraints( cvs, topology, kappa) logger.info("plumed_file_content:\n\n%s\n", plumed_file_content) # stringpath = np.loadtxt(cvs_len5path + "string-paths-drorpath/dror_path_fixedep.txt") # stringpath = np.loadtxt(cvs_len5path + "string-paths-3p0g-3sn6/straight4points.txt") create_targetmd_input(cvs, stringpath, steps_per_point=utils.rint(time_ns * 1e6 / len(stringpath)), backwards=False, kappa=kappa)
def peak_local_max_wrap( image, min_distance=1, threshold_abs=None, threshold_rel=None, num_peaks=np.inf, ): """ adapted from skimage to support theta wrap """ if np.all(image == image.flat[0]): return np.empty((0, 2), np.int) # Non maximum filter # if footprint is not None: # image_max = ndi.maximum_filter(image, footprint=footprint, # mode='wrap') # else: # size = 2 * min_distance + 1 # image_max = ndi.maximum_filter(image, size=size, mode='wrap') # maximum filter with gaussian kernel ker = cv2.getGaussianKernel(U.rint(2 * min_distance + 1), sigma=2.0) ker = ker * ker.T image_max = ndi.maximum_filter(image, footprint=ker, mode='wrap') # alternatively, # size = 2 * min_distance + 1 # image_max = ndi.maximum_filter(image, size=size, mode='wrap') mask = image == image_max # find top peak candidates above a threshold thresholds = [] if threshold_abs is None: threshold_abs = image.min() thresholds.append(threshold_abs) if threshold_rel is not None: thresholds.append(threshold_rel * image.max()) if thresholds: mask &= image > max(thresholds) # Select highest intensities (num_peaks) coordinates = _get_high_intensity_peaks(image, mask, num_peaks) return coordinates
def to_node_id(self, iteration, point_idx): return "i{}p{}".format(utils.rint(iteration), utils.rint(point_idx))