def __init__(self) -> None: self.overworld_raw_data = list( open("data/overworld-data.bin", 'rb').read(0x300)) self.level_1_to_6_raw_data = list( open("data/level-1-6-data.bin", 'rb').read(0x300)) self.level_7_to_9_raw_data = list( open("data/level-7-9-data.bin", 'rb').read(0x300)) self.level_metadata = list( open("data/level-metadata.bin", 'rb').read(0x9D8)) self.overworld_caves: List[Cave] = [] self.level_1_to_6_rooms: List[Room] = [] self.level_7_to_9_rooms: List[Room] = [] self.sprite_set_patch = Patch() self.misc_data_patch = Patch()
def generate_patches(x, y, split, balanced=False): for i in tqdm(range(20)): if split == 'train': I = np.array( Image.open('DRIVE/training/images/' + format(i + 21, '02d') + '_training.tif')) J = np.array( Image.open('DRIVE/training/1st_manual/' + format(i + 21, '02d') + '_manual1.tif')) mask = np.array( Image.open('DRIVE/training/mask/' + format(i + 21, '02d') + '_training_mask.tif')) elif split == 'test': I = np.array( Image.open('DRIVE/test/images/' + format(i + 1, '02d') + '_test.tif')) J = np.array( Image.open('DRIVE/test/1st_manual/' + format(i + 1, '02d') + '_manual1.tif')) mask = np.array( Image.open('DRIVE/test/mask/' + format(i + 1, '02d') + '_test_mask.tif')) for j in range(20000): index = i * 20000 + j try: label = None if balanced: label = int(np.random.rand() < 0.5) patch = Patch(I, J, mask, size=x.shape[1], label=label) x[index] = patch.data y[index, patch.label] = 1 except ValueError: j -= 1
def update_tags(index, entries): """ Update the Git-repo tag (possibly by removing it) of patches. """ for entry in entries: with Patch(open(entry.name, mode="r+b")) as patch: message = "Failed to update tag \"%s\" in patch \"%s\". This " \ "tag is not found." if entry.dest_head == git_sort.remotes[0]: tag_name = "Patch-mainline" try: patch.change(tag_name, index.describe(entry.dest.index)) except KeyError: raise exc.KSNotFound(message % ( tag_name, entry.name, )) except git_sort.GSError as err: raise exc.KSError("Failed to update tag \"%s\" in patch " "\"%s\". %s" % ( tag_name, entry.name, str(err), )) patch.remove("Git-repo") else: tag_name = "Git-repo" try: patch.change(tag_name, repr(entry.new_url)) except KeyError: raise exc.KSNotFound(message % ( tag_name, entry.name, ))
def create_patch(self, replace_current = False): patch = Patch(self.rom, self.patch_range, self.patch_size, 'increment') if replace_current == True: self.patches[len(self.patches) - 1] = patch else: self.patches.append(patch)
def _GetPatchForOverworldCaveData(self) -> Patch: patch = Patch() for cave_type in Range.VALID_CAVE_TYPES: cave_num = int(cave_type) - self.CAVE_TYPE_CAVE_NUM_OFFSET if cave_type == CaveType.ARMOS_ITEM_VIRTUAL_CAVE: patch.AddData( self.ARMOS_ITEM_ADDRESS, [self.overworld_caves[cave_num].GetItemAtPosition(2)]) continue if cave_type == CaveType.COAST_ITEM_VIRTUAL_CAVE: patch.AddData( self.COAST_ITEM_ADDRESS, [self.overworld_caves[cave_num].GetItemAtPosition(2)]) continue # Note that the Cave class is responsible for protecting bits 6 and 7 in its item data patch.AddData( self.OVERWORLD_DATA_START_ADDRESS + self._GetOverworldCaveDataIndex( cave_type, 0, is_second_byte=False), self.overworld_caves[cave_num].GetItemData()) patch.AddData( self.OVERWORLD_DATA_START_ADDRESS + self._GetOverworldCaveDataIndex( cave_type, 0, is_second_byte=True), self.overworld_caves[cave_num].GetPriceData()) return patch
def computePatch(feature, potentialFeature, referenceImage) : sensedImage = potentialFeature.getImage() opticalCentre1 = referenceImage.getOpticalCentre() projectionMatrix1 = referenceImage.getProjectionMatrix() projectionMatrix2 = sensedImage.getProjectionMatrix() centre = triangulate(feature, potentialFeature, projectionMatrix1, projectionMatrix2) centre = np.array([centre[0][0], centre[0][1], centre[0][2], centre[0][3]]) normal = opticalCentre1 - centre patch = Patch(centre, normal, referenceImage) # gridCoordinate1 = projectPatch(referenceImage.getProjectionMatrix(), patch) # gridCoordinate2 = projectPatch(sensedImage.getProjectionMatrix(), patch) # ref = cv.imread(referenceImage.getImageName()) # fundamentalMatrix = referenceImage.getFundamentalMatrix(potentialFeature.getImage().getImageID()) # coordinate = np.array([ # feature.getX(), # feature.getY(), # 1 # ]) # epiline = fundamentalMatrix @ coordinate # img = sensedImage.computeFeatureMapSatisfyingEpiline(epiline) # epiline_x = (int(-epiline[2] / epiline[0]), 0) # epiline_y = (int((-epiline[2] - (epiline[1]*480)) / epiline[0]), 480) # cv.line(img, epiline_x, epiline_y, (255, 0, 0), 1) # cv.circle(ref, (int(feature.getX()), int(feature.getY())), 4, (0, 0, 255), -1) # cv.rectangle(ref, (int(gridCoordinate1[0][0][0]), int(gridCoordinate1[0][0][1])), (int(gridCoordinate1[4][4][0]), int(gridCoordinate1[4][4][1])), (0, 255, 0), -1) # cv.rectangle(img, (int(gridCoordinate2[0][0][0]), int(gridCoordinate2[0][0][1])), (int(gridCoordinate2[4][4][0]), int(gridCoordinate2[4][4][1])), (0, 255, 0), -1) # cv.imshow(f'Reference Image', ref) # cv.imshow(f'Sensed Image', img) # cv.waitKey(0) # cv.destroyAllWindows() return patch
def load(self, filename): """ Loads a surface from a text file. The file must have the following structure: Each line is a control point. It contains all 3 coordinates, separated by spaces only. The file must contain n * 16 control points, where n is a positive integer. """ self.patches = [] control_points = np.loadtxt(filename) nb_of_patches = int(len(control_points) / 16) patches_control_points = np.split(control_points, nb_of_patches) for patch_nb in range(len(patches_control_points)): patch = Patch() patch_control_points = patches_control_points[patch_nb] for i in range(4): for j in range(4): z = patch_control_points[4 * i + j, 2] y = patch_control_points[4 * i + j, 1] x = patch_control_points[4 * i + j, 0] patch.control_points[i, j] = np.array([x, y, z]) self.patches.append(patch)
def processFile(self, github_file, committed_by): patch = Patch(patch_text=github_file['patch'], filepath=github_file['filename'], repo=self.repo, account=self.user, committed_by=committed_by) patch.updateTodos()
def create_patch(self) -> Patch: last = self.version self._increment_version() current = self.version patch = Patch(last, current) self.patches[last] = patch self.current_patch = patch return patch
def setup(): with open("input.txt") as f: for line in f: coord = line.split(',') x = int(coord[0]) y = int(coord[1].strip()) patches.append(Patch(x, y)) usedPoints.append([x, y])
def ResetToVanilla(self) -> None: self._ReadOverworldData() self.level_1_to_6_rooms = self._ReadDataForLevelGrid( self.level_1_to_6_raw_data) self.level_7_to_9_rooms = self._ReadDataForLevelGrid( self.level_7_to_9_raw_data) self.level_metadata = list( open("data/level-metadata.bin", 'rb').read(0x9D8)) self.sprite_set_patch = Patch()
def GetPatch(self) -> Patch: patch = Patch() patch += self._GetPatchForLevelGrid( self.LEVEL_1_TO_6_DATA_START_ADDRESS, self.level_1_to_6_rooms) patch += self._GetPatchForLevelGrid( self.LEVEL_7_TO_9_DATA_START_ADDRESS, self.level_7_to_9_rooms) patch += self._GetPatchForLevelMetadata() patch += self._GetPatchForOverworldCaveData() patch += self._GetPatchForOverworldData() patch += self.sprite_set_patch return patch
def _GetPatchForLevelGrid(self, start_address: int, rooms: List[Room]) -> Patch: patch = Patch() for room_num in Range.VALID_ROOM_NUMBERS: room_data = rooms[room_num].GetRomData() assert len(room_data) == self.NUM_BYTES_OF_DATA_PER_ROOM for table_num in range(0, self.NUM_BYTES_OF_DATA_PER_ROOM): patch.AddData( start_address + table_num * self.LEVEL_TABLE_SIZE + room_num, [room_data[table_num]]) return patch
def computePatch(feat1, feat2, ref): logging.info(f'IMAGE {ref.id:02d}:Constructing patch.') img = feat2.image opticalCentre = ref.opticalCentre projectionMatrix1 = ref.projectionMatrix projectionMatrix2 = img.projectionMatrix centre = triangulate(feat1, feat2, projectionMatrix1, projectionMatrix2)[0] normal = opticalCentre - centre normal /= norm(normal) patch = Patch(centre, normal, ref) return patch
def evaluate_grid_masked(self, x0, y0, mask, fx, fy, derivs=False): ''' mask: np array of booleans (NOT Patch object!) ''' from mix import c_gauss_2d_masked h, w = mask.shape result = np.zeros((h, w), np.float32) xderiv = yderiv = None if derivs: xderiv = np.zeros_like(result) yderiv = np.zeros_like(result) # print 'gauss_2d_masked:', int(x0), int(y0), int(w), int (h), float(fx), float(fy), # print ' ', self.amp.astype(np.float32), # print ' ', self.mean.astype(np.float32), # print ' ', self.var.astype(np.float32), # print ' ', 'res', (result.shape, result.dtype), # if xderiv is not None: # print ' ', 'xd', (xderiv.shape, xderiv.dtype), # if yderiv is not None: # print ' ', 'yd', (yderiv.shape, yderiv.dtype), # print ' ', 'mask', mask.shape, mask.dtype rtn = c_gauss_2d_masked(int(x0), int(y0), int(w), int(h), float(fx), float(fy), self.amp.astype(np.float32), self.mean.astype(np.float32), self.var.astype(np.float32), result, xderiv, yderiv, mask) # print 'gauss_2d_masked returned.' assert (rtn == 0) if derivs: return (Patch(x0, y0, result), Patch(x0, y0, xderiv), Patch(x0, y0, yderiv)) return Patch(x0, y0, result)
def evaluate_grid_dstn(self, x0, x1, y0, y1, cx, cy): ''' [x0,x1): (int) X values to evaluate [y0,y1): (int) Y values to evaluate (cx,cy): (float) pixel center of the MoG ''' from mix import c_gauss_2d_grid assert(self.D == 2) result = np.zeros((y1-y0, x1-x0)) rtn = c_gauss_2d_grid(x0, x1, y0, y1, cx, cy, self.amp, self.mean,self.var, result) if rtn == -1: raise RuntimeError('c_gauss_2d_grid failed') return Patch(x0, y0, result)
def find_commit(commit, series, mode="rb"): """ Caller must chdir to where the entries in series can be found. """ for name in filter_series(series): patch = Patch(open(name, mode="rb")) found = False if commit in [firstword(value) for value in patch.get("Git-commit") if value]: found = True yield name, patch patch.writeback() if found: return raise exc.KSNotFound()
def generate_patches(scaled_imgs, constants, all_patches): """Generate patches for all scaled images.""" patch_size = constants.PATCH_SIZE step = 1 if all_patches else 2 patches = [] for k, sc in enumerate(scaled_imgs): img_patches = [] for i in range(0, sc.shape[0] - patch_size, step): for j in range(0, sc.shape[1] - patch_size, step): raw_patch = sc[i:i + patch_size, j:j + patch_size, :] patch = Patch( raw_patch=raw_patch, patch_size=patch_size, ) patch.store(sc, [i, j]) img_patches.append(patch) patches.append(img_patches) return patches
def generate_patches(scaled_imgs, constants): patch_size = constants.PATCH_SIZE std_dev_threshold = constants.STD_DEV_THRESHOLD patches = [] for k, sc in enumerate(scaled_imgs): img_patches = [] for i in range(sc.shape[0] - patch_size): for j in range(sc.shape[1] - patch_size): raw_patch = sc[i:i + patch_size, j:j + patch_size, :] patch = Patch( raw_patch=raw_patch, patch_size=patch_size, ) if patch.std_dev > std_dev_threshold: patch.store(sc, [i, j]) img_patches.append(patch) patches.append(img_patches) return patches
def find_commit(commit, series, mode="rb"): """ commit: unabbreviated git commit id series: list of lines from series.conf mode: mode to open the patch files in, should be "rb" or "r+b" Caller must chdir to where the entries in series can be found. Returns patch.Patch instances """ for name in filter_series(series): patch = Patch(open(name, mode=mode)) found = False if commit in [ firstword(value) for value in patch.get("Git-commit") if value ]: found = True yield name, patch patch.writeback() if found: return raise exc.KSNotFound()
def randomize(self, patch_length, patch_width, min_height=0, max_height=0.2): """ Creates a random Bézier surface. The resulting surface will be C0 only. patch_length is the number of patches along the x axis that will be generated. patch_width is the number of patches along the y axis that will be generated. """ self.patches = [] for w, l in product(range(patch_width), range(patch_length)): # Patches are created and stored in a 1D array. # The patch at coordinate (x, y) can be retrieved as self.patches[x + y * patch_length] # However this structure is true ONLY in this generation fuction, as in general, if # we import another surface, it may not follow this particular pattern. # It is however useful in this generation, as it allows us to easily correct random # patches to make them c0, without checking each control points 1 by 1. patch = Patch() patch.randomize(min_x=l, max_x=l + 1, min_y=w, max_y=w + 1, min_z=min_height, max_z=max_height) self.patches.append(patch) # make the connections continuous for l, w in product(range(1, patch_length), range(patch_width)): previous_patch = self.patches[(l - 1) + w * patch_length] current_patch = self.patches[l + w * patch_length] for i in range(4): current_patch[0, i] = previous_patch[3, i] for l, w in product(range(patch_length), range(1, patch_width)): previous_patch = self.patches[l + (w - 1) * patch_length] current_patch = self.patches[l + w * patch_length] for i in range(4): current_patch[i, 0] = previous_patch[i, 3]
def get_patches_from_slide(slide, tile_size=1024, overlap=0, limit_bounds=False): """ Splits an OpenSlide object into nonoverlapping patches Args: slide: OpenSlide object tile_size: Width and height of a single tile overlap: Number of extra pixels to add to each interior edge of a tile limit_bounds: If True, renders only non-empty slide region Returns: Array of patches """ tiles = DeepZoomGenerator(slide, tile_size=tile_size, overlap=overlap, limit_bounds=limit_bounds) level = len(tiles.level_tiles) - 1 x_tiles, y_tiles = tiles.level_tiles[level] #Note: Highest level == Highest resolution x, y = 0, 0 count, batch_count = 0, 0 patches = [] coordinate_list = [] tiled_dims = (y_tiles, x_tiles) while y < y_tiles: while x < x_tiles: new_patch_img = np.array(tiles.get_tile(level, (x,y)), dtype=np.uint8) new_patch_coords = tiles.get_tile_coordinates(level, (x,y)) if np.shape(new_patch_img) == (tile_size, tile_size, 3): new_patch = Patch(new_patch_img, new_patch_coords) patches.append(new_patch) patch_coordinates = (y,x) coordinate_list.append(patch_coordinates) count += 1 x += 1 y += 1 x = 0 return (patches, coordinate_list, tiled_dims)
def expand(self): it = 1 queue = self.patches.copy() while len(queue) > 0: p = queue.pop(0) for cell in p.cells: C = [] for i in range(-1, 2): for j in range(-1, 2): if i == 0 and j == 0: continue idx = (cell.y + i * 2, cell.x + j * 2) if idx in self.cells[cell.ref_idx]: C.append(self.cells[cell.ref_idx][idx]) # cp = p.cam_center + p.k * p.d # p_depth = (self.extrinsics[p.ref_idx] @ np.array([*cp, 1]))[-1] C_filtered = [] for c in C: neccessary = True if len(c.q) > 0: for pp in c.q: # cpp = pp.cam_center + pp.k * pp.d # pp_depth = (self.extrinsics[pp.ref_idx] @ np.array([*cpp, 1]))[-1] # rho1 = 2 * self.intrinsic_inv[0, 0] * (p_depth + pp_depth) / 2 # if np.abs(np.dot(cp - cpp, sph2norm(p.theta, p.phi))) + np.abs(np.dot(cp - cpp, sph2norm(pp.theta, pp.phi))) < 2 * rho1: if self.is_neighbor(p, pp): neccessary = False break if neccessary and len(c.q_star) > 0: for pp in c.q_star: if self.gp(pp, pp.ref_idx, pp.v_star) < 0.3: neccessary = False break if neccessary: C_filtered.append(c) C = C_filtered # print(len(C)) for c in C: pprime = Patch(patch=p) # set new pc n = sph2norm(p.theta, p.phi) p_center = p.cam_center + p.k * p.d plane = -np.dot(n, p_center) pt = np.array([c.x + 1, c.y + 1, 1]) pt_world = np.linalg.pinv(self.extrinsics[pprime.ref_idx]) @ self.intrinsic_inv @ pt pt_world = pt_world[:3] / pt_world[-1] cam2pt = pt_world - p.cam_center pprime_center = -(plane + np.dot(n, p.cam_center)) / np.dot(n, cam2pt) * cam2pt + p.cam_center # print(p_center) # print(pprime_center) pprime.d = pprime_center - p.cam_center pprime.k = np.linalg.norm(pprime.d) pprime.d /= pprime.k # import pdb; pdb.set_trace() proj_ref = pprime.project_onto_img(self.intrinsic, self.extrinsics[pprime.ref_idx]) v_star = [] for cand in pprime.v: proj_cand = pprime.project_onto_img(self.intrinsic, self.extrinsics[cand]) zncc = calc_zncc(self.grays[pprime.ref_idx], self.grays[cand], proj_ref, proj_cand) if 1. - zncc < 0.6: v_star.append(cand) pprime.v_star = v_star if len(pprime.v_star) < 2: continue def gp(x): backup = pprime.k, pprime.theta, pprime.phi pprime.k, pprime.theta, pprime.phi = x res = self.gp(pprime, pprime.ref_idx, pprime.v_star) pprime.k, pprime.theta, pprime.phi = backup return res def gp_grad(x): backup = pprime.k, pprime.theta, pprime.phi pprime.k, pprime.theta, pprime.phi = x res = self.gp_grad(pprime, pprime.ref_idx, pprime.v_star) pprime.k, pprime.theta, pprime.phi = backup return res # print(patch.k, patch.theta, patch.phi) best_x = optimize.fmin_cg(gp, np.array([pprime.k, pprime.theta, pprime.phi]), fprime=gp_grad, disp=False) pprime.k, pprime.theta, pprime.phi = best_x # determine depth test threshold n = sph2norm(pprime.theta, pprime.phi) pprime_center = pprime.cam_center + pprime.k * pprime.d plane = -np.dot(n, pprime_center) pt = np.array([c.x + 3, c.y + 1, 1]) # offset two pixels pt_world = np.linalg.pinv(self.extrinsics[pprime.ref_idx]) @ self.intrinsic_inv @ pt pt_world = pt_world[:3] / pt_world[-1] cam2pt = pt_world - pprime.cam_center delta = np.linalg.norm(-(plane + np.dot(n, pprime.cam_center)) / np.dot(n, cam2pt) * cam2pt + pprime.cam_center - pprime_center) pprime_depth = (self.extrinsics[pprime.ref_idx] @ np.array([*pprime_center, 1]))[-1] for cand in range(len(self.grays)): if cand == pprime.ref_idx: continue proj = self.intrinsic @ self.extrinsics[cand] @ np.array([*(pprime.cam_center + pprime.k * pprime.d), 1]) proj = (proj[:2] / proj[-1]).astype(np.int) if (proj[1], proj[0]) in self.cells[cand]: if len(self.cells[cand][(proj[1], proj[0])].q) > 0: valid = True for pp in self.cells[cand][(proj[1], proj[0])].q: pp = self.cells[cand][(proj[1], proj[0])].q[0] pp_proj = self.extrinsics[pp.ref_idx] @ np.array([*(pp.cam_center + pp.k * pp.d), 1]) depth = pp_proj[-1] if pprime_depth > depth + delta: valid = False break if valid: pprime.v.append(cand) pprime.v = list(set(pprime.v)) v_star = [] for cand in pprime.v: proj_cand = pprime.project_onto_img(self.intrinsic, self.extrinsics[cand]) zncc = calc_zncc(self.grays[pprime.ref_idx], self.grays[cand], proj_ref, proj_cand) if 1. - zncc < 0.3: v_star.append(cand) pprime.v_star = list(set(v_star)) if len(pprime.v_star) < 2: continue queue.append(pprime) self.patches.append(pprime) for idx in pprime.v: proj = self.intrinsic @ self.extrinsics[idx] @ np.array([*pprime_center, 1]) proj = (proj[:2] / proj[-1]).astype(np.int) if (proj[1], proj[0]) in self.cells[idx]: self.cells[idx][(proj[1], proj[0])].q.append(pprime) for idx in pprime.v_star: proj = self.intrinsic @ self.extrinsics[idx] @ np.array([*pprime_center, 1]) proj = (proj[:2] / proj[-1]).astype(np.int) if (proj[1], proj[0]) in self.cells[idx]: self.cells[idx][(proj[1], proj[0])].q_star.append(pprime) pprime.cells.append(self.cells[idx][(proj[1], proj[0])]) print('processed one: {}, current queue length: {}'.format(len(self.patches), len(queue))) colors = np.zeros((len(self.patches), 3)) vis = self.rgbs[0].copy() for i, patch in enumerate(self.patches): pts = patch.project_onto_img(self.intrinsic, self.extrinsics[0]) pt = pts[pts.shape[0] // 2].astype(np.int) if pt[0] >= 0 and pt[1] >= 0 and pt[0] < self.grays[0].shape[1] and pt[1] < self.grays[0].shape[0]: vis = cv2.circle(vis, (int(pt[0]), int(pt[1])), 1, color=(255, 0, 0), thickness=-1) colors[i] = self.rgbs[0][pt[1], pt[0]] cv2.imshow('patch', cv2.resize(vis[..., ::-1], (0, 0), fx=4, fy=4)) cv2.waitKey(10)
os.environ["GIT_DIR"] = repo_path repo = pygit2.Repository(repo_path) try: commit = repo.revparse_single(args.rev) except ValueError: print("Error: \"%s\" is not a valid revision." % (args.rev, ), file=sys.stderr) sys.exit(1) except KeyError: print("Error: revision \"%s\" not found in \"%s\"." % (args.rev, repo_path), file=sys.stderr) sys.exit(1) if args.followup: with Patch(io.BytesIO(commit.message.encode())) as patch: try: fixes = series_conf.firstword(patch.get("Fixes")[0]) except IndexError: print("Error: no \"Fixes\" tag found in commit \"%s\"." % (str(commit.id)[:12]), file=sys.stderr) sys.exit(1) fixes = str(repo.revparse_single(fixes).id) series = open("series") cwd = os.getcwd() os.chdir("patches") try: with series_conf.find_commit(fixes, series) as ( name,
def matching(self): feature_points_mask = [np.ones((self.feature_points[i].shape[0]), dtype=np.bool) for i in range(len(self.grays))] for i in range(len(self.grays) - 1): for camera_point in tqdm(self.camera_feature_points[i][feature_points_mask[i]]): corrs = [] for j in range(len(self.grays)): if i == j: continue epiline = self.intrinsic_inv.T @ self.Fs[(i, j)] @ camera_point epiline /= np.linalg.norm(epiline[:2]) dist2epiline = np.abs(np.sum(self.feature_points[j][feature_points_mask[j]] * epiline[None], -1)) close_pts = self.camera_feature_points[j][feature_points_mask[j]][dist2epiline < 3] for pt in close_pts: c = np.asarray(opt_triangulate([self.extrinsics[i], self.extrinsics[j]], [[camera_point[0], camera_point[1], pt[0], pt[1]]])[0]) c = c[:3] corrs.append((j, pt, c, np.linalg.norm(c - self.camera_centers[i]))) # if len(close_pts) > 10: # img = self.rgbs[j].copy() # img_ref = self.rgbs[i].copy() # cv2.circle(img_ref, (self.feature_points[i][k][0], self.feature_points[i][k][1]), 3, color=(255, 0, 0), thickness=-1) # for point in close_pts: # img = cv2.circle(img, (int(point[0]), int(point[1])), 1, color=(255, 0, 0), thickness=-1) # cv2.imshow('img', img[:, :, ::-1]) # cv2.imshow('img_ref', img_ref[:, :, ::-1]) # cv2.waitKey() corrs.sort(key=lambda x: x[3]) for (j, pt, c, dist) in corrs: patch = Patch(c, self.intrinsic_inv, self.extrinsics[i], i) # first round proj_i = patch.project_onto_img(self.intrinsic, self.extrinsics[i]) c = patch.cam_center + patch.k * patch.d co = c[None] - np.stack(self.camera_centers) co /= np.linalg.norm(co, axis=-1, keepdims=True) cos = co @ sph2norm(patch.theta, patch.phi) vp = list(np.where(cos > 0.5)[0]) v_star = [] for cand in vp: proj_cand = patch.project_onto_img(self.intrinsic, self.extrinsics[cand]) zncc = calc_zncc(self.grays[i], self.grays[cand], proj_i, proj_cand) if 1. - zncc < 0.6: v_star.append(cand) if len(v_star) < 2: continue def gp(x): backup = patch.k, patch.theta, patch.phi patch.k, patch.theta, patch.phi = x res = self.gp(patch, patch.ref_idx, v_star) patch.k, patch.theta, patch.phi = backup return res def gp_grad(x): backup = patch.k, patch.theta, patch.phi patch.k, patch.theta, patch.phi = x res = self.gp_grad(patch, patch.ref_idx, v_star) patch.k, patch.theta, patch.phi = backup return res # print(patch.k, patch.theta, patch.phi) best_x = optimize.fmin_cg(gp, np.array([patch.k, patch.theta, patch.phi]), fprime=gp_grad, disp=False) patch.k, patch.theta, patch.phi = best_x # print(patch.k, patch.theta, patch.phi) # conjugate gradient descent my implementation # last_grad = None # for it in range(100): # if it == 0: # last_grad = gp_grad() # p = -last_grad # last_p = p # else: # beta = np.dot(last_grad, last_grad) / np.dot(last_last_grad, last_last_grad) # p = -last_grad + beta * last_p # gp_before = gp() # grad_before = gp_grad() # alpha = 1. # k, theta, phi = patch.k, patch.theta, patch.phi # patch.k = float(k + alpha * p[0]) # patch.theta = float(theta + alpha * p[1]) # patch.phi = float(phi + alpha * p[2]) # patch.refresh() # while gp() > gp_before + 1 / 2 * alpha * np.dot(p, grad_before): # alpha *= 0.5 # patch.k = float(k + alpha * p[0]) # patch.theta = float(theta + alpha * p[1]) # patch.phi = float(phi + alpha * p[2]) # patch.refresh() # last_p = p # last_last_grad = last_grad # last_grad = gp_grad() # if np.any(np.isnan(last_grad)): # import pdb; pdb.set_trace() # if np.linalg.norm(last_grad) < 0.1: # break # second round proj_i = patch.project_onto_img(self.intrinsic, self.extrinsics[i]) c = patch.cam_center + patch.k * patch.d co = c[None] - np.stack(self.camera_centers) co /= np.linalg.norm(co, axis=-1, keepdims=True) cos = co @ sph2norm(patch.theta, patch.phi) vp = list(np.where(cos > 0.5)[0]) v_star = [] for cand in vp: proj_cand = patch.project_onto_img(self.intrinsic, self.extrinsics[cand]) zncc = calc_zncc(self.grays[i], self.grays[cand], proj_i, proj_cand) if 1. - zncc < 0.3: v_star.append(cand) if len(v_star) < 2: continue patch.v = vp patch.v_star = v_star to_remove = [] for idx in vp: proj = self.intrinsic @ self.extrinsics[idx] @ np.array([*c, 1]) proj = (proj[:2] / proj[-1]).astype(np.int) if (proj[1], proj[0]) in self.cells[idx]: self.cells[idx][(proj[1], proj[0])].q.append(patch) for idx in v_star: proj = self.intrinsic @ self.extrinsics[idx] @ np.array([*c, 1]) proj = (proj[:2] / proj[-1]).astype(np.int) if (proj[1], proj[0]) in self.cells[idx]: self.cells[idx][(proj[1], proj[0])].q_star.append(patch) patch.cells.append(self.cells[idx][(proj[1], proj[0])]) for pt_idx in self.cells[idx][(proj[1], proj[0])].feature_points_idx: to_remove.append((idx, pt_idx)) for (idx, pt_idx) in to_remove: feature_points_mask[idx][pt_idx] = False self.patches.append(patch) colors = np.zeros((len(self.patches), 3)) vis = self.rgbs[0].copy() for i, patch in enumerate(self.patches): pts = patch.project_onto_img(self.intrinsic, self.extrinsics[0]) pt = pts[pts.shape[0] // 2].astype(np.int) if pt[0] >= 0 and pt[1] >= 0 and pt[0] < self.grays[0].shape[1] and pt[1] < self.grays[0].shape[0]: vis = cv2.circle(vis, (int(pt[0]), int(pt[1])), 1, color=(255, 0, 0), thickness=-1) colors[i] = self.rgbs[0][pt[1], pt[0]] cv2.imshow('patch', cv2.resize(vis[..., ::-1], (0, 0), fx=4, fy=4)) draw_patches(self.patches, colors)
def main(): args = parse_command_line() root_dir = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')) config.config_init(args.version, args.revision, args.version_name, args.sdk_root_path, args.sdk_version, root_dir) sdk = Sdk(config.ARTIFACTS_ROOT, config.SDK_VERSION) # Assumes that source root dir is .. since build.py is ran in directory build_scripts patch_dir = os.path.join(root_dir, 'patches') try: if args.clean: clean.clean_all(sdk) if args.create_patch_filename: sdk.prepare_sdk() old_path = sdk.path tempdir_path = None try: tempdir_path = tempfile.mkdtemp(prefix='nordicsemi') sdk.path = os.path.join(tempdir_path, "orig_sdk") sdk.prepare_sdk() p = Patch(patch_dir=patch_dir, apply_patch_root_dir=sdk.path, strip=0 # The old patches has 4 more components ) p.create_patch(tempdir_path, old_path, os.path.join(patch_dir, args.create_patch_filename)) finally: sdk.path = old_path shutil.rmtree(tempdir_path) if args.dependencies: sdk.prepare_sdk() patch_tag_file = posixpath.join(sdk.path, ".patched") if os.path.exists(patch_tag_file): logger.info("Patches are already applied to this SDK, skipping patching") else: open(patch_tag_file, 'w').close() p = Patch(patch_dir=patch_dir, apply_patch_root_dir=sdk.path, strip=0 # The old patches has 4 more components ) p.apply_patches(dry_run=False) if args.build: serialization_dll.build() if args.test: error_code = tests.do_testing() if error_code != 0: return error_code if args.package: package_release() if args.examples: examples.build_examples() except Exception, ex: logger.exception(ex) return -1
def from_patch(self, index, name, current_head, move_upstream): """ This is where we decide a patch line's fate in the sorted series.conf The following factors determine how a patch is sorted: * commit found in index * patch's series.conf current_head is indexed (ie. the local repo fetches from that remote) * patch appears to have moved downstream/didn't move/upstream * patch's tag is good ("Git-repo:" == current_head.url) * patches may be moved upstream between subsystem sections """ self.name = name if not os.path.exists(name): raise exc.KSError("Could not find patch \"%s\"" % (name, )) with Patch(open(name, mode="rb")) as patch: commit_tags = patch.get("Git-commit") repo_tags = patch.get("Git-repo") if not commit_tags: self.dest_head = git_sort.oot return class BadTag(Exception): pass def get_commit(value): if not value: raise BadTag(value) tag = series_conf.firstword(value) if not self.commit_match.match(tag): raise BadTag(tag) return tag try: self.revs = [get_commit(value) for value in commit_tags] except BadTag as e: raise exc.KSError("Git-commit tag \"%s\" in patch \"%s\" is not a " "valid revision." % ( e.args[0], name, )) rev = self.revs[0] if len(repo_tags) > 1: raise exc.KSError("Multiple Git-repo tags found. Patch \"%s\" is " "tagged improperly." % (name, )) elif repo_tags: repo = git_sort.RepoURL(repo_tags[0]) elif commit_tags: repo = git_sort.remotes[0].repo_url self.new_url = None try: ic = index.lookup(rev) except git_sort.GSKeyError: # commit not found if current_head not in index.repo_heads: # repo not indexed if repo == current_head.repo_url: # good tag self.dest_head = current_head else: # bad tag raise exc.KSError( "There is a problem with patch \"%s\". " "The Git-repo tag is incorrect or the patch is in the " "wrong section of series.conf and (the Git-commit tag " "is incorrect or the relevant remote is outdated or " "not available locally) or an entry for this " "repository is missing from \"remotes\". In the last " "case, please edit \"remotes\" in " "\"scripts/git_sort/git_sort.py\" and commit the " "result. Manual intervention is required." % (name, )) else: # repo is indexed if repo == current_head.repo_url: # good tag raise exc.KSError( "There is a problem with patch \"%s\". " "Commit \"%s\" not found in git-sort index. " "The remote fetching from \"%s\" needs to be fetched " "or the Git-commit tag is incorrect or the patch is " "in the wrong section of series.conf. Manual " "intervention is required." % ( name, rev, current_head.repo_url, )) else: # bad tag raise exc.KSError( "There is a problem with patch \"%s\". " "The Git-repo tag is incorrect or the patch is in the " "wrong section of series.conf. Manual intervention is " "required." % (name, )) else: # commit found msg_bad_tag = "There is a problem with patch \"%s\". " \ "The Git-repo tag is incorrect or the patch is in " \ "the wrong section of series.conf. Manual " \ "intervention is required." % (name,) if current_head not in index.repo_heads: # repo not indexed if ic.head > current_head: # patch moved downstream if repo == current_head.repo_url: # good tag self.dest_head = current_head else: # bad tag raise exc.KSError(msg_bad_tag) elif ic.head == current_head: # patch didn't move raise exc.KSException( "Head \"%s\" is not available locally but commit " "\"%s\" found in patch \"%s\" was found in that head." % ( ic.head, rev, name, )) elif ic.head < current_head: # patch moved upstream if move_upstream: # move patches between subsystem sections self.dest_head = ic.head self.dest = ic if repo != ic.head.repo_url: # bad tag self.new_url = ic.head.repo_url else: # do not move patches between subsystem sections if repo == current_head.repo_url: # good tag self.dest_head = current_head else: # bad tag raise exc.KSError(msg_bad_tag) else: # repo is indexed if ic.head > current_head: # patch moved downstream if repo == current_head.repo_url: # good tag raise exc.KSError( "There is a problem with patch \"%s\". " "The patch is in the wrong section of series.conf " "or the remote fetching from \"%s\" needs to be " "fetched or the relative order of \"%s\" and " "\"%s\" in \"remotes\" is incorrect. Manual " "intervention is required." % ( name, current_head.repo_url, ic.head, current_head, )) else: # bad tag raise exc.KSError( "There is a problem with patch \"%s\". " "The patch is in the wrong section of series.conf " "or the remote fetching from \"%s\" needs to be " "fetched. Manual intervention is required." % ( name, current_head.repo_url, )) elif ic.head == current_head: # patch didn't move self.dest_head = ic.head self.dest = ic if repo != ic.head.repo_url: # bad tag self.new_url = ic.head.repo_url elif ic.head < current_head: # patch moved upstream if move_upstream: # move patches between subsystem sections self.dest_head = ic.head self.dest = ic if repo != ic.head.repo_url: # bad tag self.new_url = ic.head.repo_url else: # do not move patches between subsystem sections if repo == current_head.repo_url: # good tag self.dest_head = current_head self.dest = ic else: # bad tag raise exc.KSError(msg_bad_tag)
def __init__(self, text_speed: str, phrase: str) -> None: self.patch = Patch() self.text_speed = text_speed self.phrase = phrase
def _GetPatchForOverworldData(self) -> Patch: patch = Patch() for screen_num in Range.VALID_ROOM_NUMBERS: addr = 0x80 + int(screen_num) patch.AddData(0x18410 + addr, [self.overworld_raw_data[addr]]) return patch
def _GetPatchForLevelMetadata(self) -> Patch: patch = Patch() patch.AddData(self.LEVEL_METADATA_ADDRESS, self.level_metadata) return patch