def run(self): print 'Initializing planner!' self.planner = Planner.get(self.rconfig) print 'Running planner' b = Benchmark() self.planner.run() b.stop() print 'Planner done! Took : %s' % str(b) self.plannerDone.emit()
def project_diffusion(self): print 'Projecting diffusion...' bench = Benchmark() start_polygons = len(self.diffusion.polygons) # Save in case we want to reference it self.diffusion_original = self.diffusion if False: self.diffusion.show() self.polysilicon.show() #self.diffusioni = self.diffusion_original.subtract(self.polysilicon) #self.diffusion = self.diffusioni.to_layer() self.diffusion = self.diffusion_original.subtract(self.polysilicon) # Find intersection with poly to form transistors # Require 2, some chips use diffusion for conduction to bypass metal # 4003 overlaps diffusion and poly because they split a contact across them # Subtract out the poly from diffusion # We can then use the same proximity algorithm as before # However, we will save intersections to get a better idea of correct transistor mapping end_polygons = len(self.diffusion.polygons) print 'Projected diffusion %d => %d polygons in %s' % (start_polygons, end_polygons, repr(bench)) if False: self.diffusion.show() #self.polysilicon.show() #self.diffusion_original.show() sys.exit(1)
def run(self): bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() fns = [] # Copy project so we can trash it project = self.project.copy() for il in project.get_image_lines(): fns.append(il.get_name()) self.icm = ImageCoordinateMap.from_tagged_file_names(fns) pre_opt(project, self.icm) prepare_pto(project, reoptimize=False) # "PToptimizer out.pto" args = ["PToptimizer"] args.append(project.get_a_file_name()) print 'Optimizing %s' % project.get_a_file_name() #raise Exception() #self.project.save() rc = execute.without_output(args) if rc != 0: raise Exception('failed position optimization') # API assumes that projects don't change under us project.reopen() # final rms error 24.0394 units rms_error = None for l in project.get_comment_lines(): if l.find('final rms error') >= 00: rms_error = float(l.split()[4]) break print 'Optimize: RMS error of %f' % rms_error # Filter out gross optimization problems if self.rms_error_threshold and rms_error > self.rms_error_threshold: raise Exception("Max RMS error threshold %f but got %f" % (self.rms_error_threshold, rms_error)) print 'Merging project...' merge_pto(project, self.project) if self.debug: print self.project bench.stop() print 'Optimized project in %s' % bench
def rebuild_qt(self): bench = Benchmark() rect_l = list() for polygon in self.polygons: rect_l.append(QTUVPolygon(polygon)) self.qt = PolygonQuadTree(rect_l) print 'Finished building %s quadtree (%d elements), took: %s' % ( self.name, len(rect_l), repr(bench))
def run(self): bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() fns = [] # Copy project so we can trash it project = self.project.copy() for il in project.get_image_lines(): fns.append(il.get_name()) self.icm = ImageCoordinateMap.from_tagged_file_names(fns) print 'Verbose: %d' % self.debug print 'working direclty on %s' % self.project.get_a_file_name() pre_opt(self.project, self.icm, verbose=self.debug, stdev=self.stdev) bench.stop() print 'Optimized project in %s' % bench
def process_image(self, pim, st_bounds): ''' A tile is valid if its in a safe location There are two ways for the location to be safe: -No neighboring tiles as found on canvas edges -Sufficiently inside the blend area that artifacts should be minimal ''' bench = Benchmark() [x0, x1, y0, y1] = st_bounds gen_tiles = 0 print # TODO: get the old info back if I miss it after yield refactor print 'Phase 4: chopping up supertile' self.msg('step(x: %d, y: %d)' % (self.tw, self.th), 3) #self.msg('x in xrange(%d, %d, %d)' % (xt0, xt1, self.tw), 3) #self.msg('y in xrange(%d, %d, %d)' % (yt0, yt1, self.th), 3) for (y, x) in self.gen_supertile_tiles(st_bounds): # If we made it this far the tile can be constructed with acceptable enblend artifacts row = self.y2row(y) col = self.x2col(x) # Did we already do this tile? if self.is_done(row, col): # No use repeating it although it would be good to diff some of these if self.verbose: print 'Rejecting tile x%d, y%d / r%d, c%d: already done' % ( x, y, row, col) continue # note that x and y are in whole pano coords # we need to adjust to our frame # row and col on the other hand are used for global naming self.make_tile(pim, x - x0, y - y0, row, col) gen_tiles += 1 bench.stop() print 'Generated %d new tiles for a total of %d / %d in %s' % ( gen_tiles, len( self.closed_list), self.net_expected_tiles, str(bench)) if gen_tiles == 0: raise Exception("Didn't generate any tiles")
def find_and_merge_nets(self): # Combine polygons at a net level on the same layer # Only needed if you have bad input polygons # Really would be better to pre-process input to combine them #bench = Benchmark() #self.condense_polygons() #print 'Polygons condensed in %s' % repr(bench) #self.show_nets() #sys.exit(1) self.verify_net_index() # Note that you cannot have diffusion and poly, via is for one or the other bench = Benchmark() self.merge_metal_vias() print 'Metal and vias merged in %s' % repr(bench) #self.show_nets() #self.verify_net_index() #sys.exit(1) self.via_check(2) # Connected poly to metal bench = Benchmark() self.merge_poly_vias_layers() print 'Poly and vias merged in %s' % repr(bench) #self.show_nets() self.verify_net_index() # Connect diffusion to metal bench = Benchmark() self.merge_diffusion_vias_layers() print 'Diffusion and vias merged in %s' % repr(bench) #self.show_nets() self.verify_net_index() self.via_check(3) #self.show_nets() print 'Finished merge'
def processCncProgress(self, pictures_to_take, pictures_taken, image, first): print 'Processing CNC progress' if first: print 'First CB with %d items' % pictures_to_take self.pb.setMinimum(0) self.pb.setMaximum(pictures_to_take) self.bench = Benchmark(pictures_to_take) else: print 'took %s at %d / %d' % (image, pictures_taken, pictures_to_take) self.bench.set_cur_items(pictures_taken) print self.bench self.pb.setValue(pictures_taken)
def process_image(self, pim, st_bounds): ''' A tile is valid if its in a safe location There are two ways for the location to be safe: -No neighboring tiles as found on canvas edges -Sufficiently inside the blend area that artifacts should be minimal ''' bench = Benchmark() [x0, x1, y0, y1] = st_bounds gen_tiles = 0 print # TODO: get the old info back if I miss it after yield refactor print 'Phase 4: chopping up supertile' self.msg('step(x: %d, y: %d)' % (self.tw, self.th), 3) #self.msg('x in xrange(%d, %d, %d)' % (xt0, xt1, self.tw), 3) #self.msg('y in xrange(%d, %d, %d)' % (yt0, yt1, self.th), 3) for (y, x) in self.gen_supertile_tiles(st_bounds): # If we made it this far the tile can be constructed with acceptable enblend artifacts row = self.y2row(y) col = self.x2col(x) # Did we already do this tile? if self.is_done(row, col): # No use repeating it although it would be good to diff some of these if self.verbose: print 'Rejecting tile x%d, y%d / r%d, c%d: already done' % (x, y, row, col) continue # note that x and y are in whole pano coords # we need to adjust to our frame # row and col on the other hand are used for global naming self.make_tile(pim, x - x0, y - y0, row, col) gen_tiles += 1 bench.stop() print 'Generated %d new tiles for a total of %d / %d in %s' % (gen_tiles, len(self.closed_list), self.net_expected_tiles, str(bench)) if gen_tiles == 0: raise Exception("Didn't generate any tiles")
if args.stampout: _outdate = IOTimestamp(sys, 'stdout') _errdate = IOTimestamp(sys, 'stderr') if exist: _outlog.out_fd.write('\n') _outlog.out_fd.write('\n') _outlog.out_fd.write('\n') _outlog.out_fd.write('*' * 80 + '\n') _outlog.out_fd.write('*' * 80 + '\n') _outlog.out_fd.write('*' * 80 + '\n') print 'pr0npto starting' print 'In: %s' % pto_in print 'Out: %s' % pto_out bench = Benchmark() pto = PTOProject.from_file_name(pto_in) # Make sure we don't accidently override the original pto.remove_file_name() if args.center is True: center(pto) if args.anchor: print 'Re-finding anchor' center_anchor(pto) if args.basename: print 'Converting to basename' make_basename(pto)
def run(self): if self.dry: print 'Dry run abort' return bench = Benchmark() if not self.output_project_file_name: raise Exception("need project file") #if not self.output_project_file_name: #self.project_temp_file = ManagedTempFile.get() #self.output_project_file_name = self.project_temp_file.file_name print 'Beginning stitch' print 'output project file name: %s' % self.output_project_file_name #sys.exit(1) self.init_failures() # Generate control points and merge them into a master project self.control_point_gen = get_cp_engine() # How many rows and cols to go to each side # If you hand took the pictures, this might suit you self.project = PTOProject.from_blank() if self.output_project_file_name: self.project.set_file_name(self.output_project_file_name) if os.path.exists(self.output_project_file_name): # Otherwise, we merge into it print 'WARNING: removing old project file: %s' % self.output_project_file_name os.remove(self.output_project_file_name) else: self.project.get_a_file_name(None, "_master.pto") self.project.image_file_names = self.image_file_names try: ''' Generate control points ''' self.generate_control_points() print 'Soften try: %s' % (self.soften_try,) print 'Soften ok: %s' % (self.soften_ok,) print 'Post stitch fixup...' optimize_xy_only(self.project) fixup_i_lines(self.project) fixup_p_lines(self.project) print print '***PTO project baseline final (%s / %s) data length %d***' % (self.project.file_name, self.output_project_file_name, len(self.project.get_text())) print self.failure_json_w() print # Make dead sure its saved up to date self.project.save() # having issues with this.. if self.output_project_file_name and not self.project.file_name == self.output_project_file_name: raise Exception('project file name changed %s %s', self.project.file_name, self.output_project_file_name) # TODO: missing calc opt size/width/height/fov and crop except Exception as e: sys.stdout.flush() sys.stderr.flush() print print 'WARNING: stitch FAILED' traceback.print_exc() try: fn = self.project.file_name + ".failed" print 'Attempting to save intermediate result to %s' % fn self.project.save_as(fn) except: print 'WARNING: failed intermediate save' raise e finally: bench.stop() print 'Stitch done in %s' % bench
def from_cif_init(self, file_name = "in.cif"): self.vias = Layer() self.metal = Layer() self.polysilicon = Layer() self.diffusion = Layer() self.labels = Layer() self.metal_gnd = None self.metal_vcc = None self.default_layer_names() parsed = CIFParser.parse(file_name) print 'CIF width: %d' % parsed.width print 'CIF height: %d' % parsed.height self.rebuild_layer_lists(False) # Make sizes the furthest point found for layer in self.layers + [self.labels]: #print 'Setting %s to %s' % (layer.name, parsed.width) layer.width = parsed.width layer.height = parsed.height def add_cif_polygons(uv_layer, cif_layer): print '%s: adding %d boxes' % (uv_layer.name, len(cif_layer.boxes)) for box in cif_layer.boxes: ''' CIF uses lower left coordinate system Convert to internal representation, upper left UL Vertical B 22 94 787 2735 Horizontal B 116 22 740 2793 ''' #print '.', if False: print 'start' print box.xpos print box.ypos print box.width print box.height # FIXME: change this into one operation since this now takes non-negligible amount of time #uvp = UVPolygon.from_rect(box.xpos, box.ypos, box.width, box.height) uvp = UVPolygon.from_rect_ex(box.xpos, box.ypos, box.width, box.height, flip_height = uv_layer.height) if False: print uvp uvp.show() #uvp.flip_horizontal(uv_layer.height) #print uvp #uvp.show() uv_layer.add_uvpolygon(uvp) #sys.exit(1) # uv_layer.show() #sys.exit(1) print 'Width: %d, height: %d' % (parsed.width, parsed.height) print 'Parsed labels: %d' % len(parsed.labels) for label in parsed.labels: # Make it a smallish object # Really 1 pix should be fine...but I'm more afraid of corner cases breaking things # Get it working first and then debug corner cases if needed # Maybe length should be related to text length uvpoly = UVPolygon.from_rect_ex(label.x, label.y, 20, 20, flip_height = parsed.height) uvpoly.text = label.text print uvpoly #uvpoly.show() self.labels.add_uvpolygon(uvpoly) #self.labels.show() #sys.exit(1) for layer_id in parsed.layers: layer = parsed.layers[layer_id] bench = Benchmark() # NMOS metal if layer_id == CIFLayer.NM: add_cif_polygons(self.metal, layer) # NMOS poly elif layer_id == CIFLayer.NP: add_cif_polygons(self.polysilicon, layer) # NMOS diffusion elif layer_id == CIFLayer.ND: add_cif_polygons(self.diffusion, layer) # NMOS contact elif layer_id == CIFLayer.NC: add_cif_polygons(self.vias, layer) else: raise Exception('Unsupported layer type %s' % repr(layer_id)) print bench #self.compute_wh() self.init()
def run(self): bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() # Copy project so we can trash it self.opt_project = self.project.copy() self.prepare_pto(self.opt_project) print 'Building image coordinate map' i_fns = [] for il in self.opt_project.image_lines: i_fns.append(il.get_name()) self.icm = ImageCoordinateMap.from_file_names(i_fns) print 'Built image coordinate map' if self.icm.width() <= self.tw: raise Exception('Decrease tile width') if self.icm.height() <= self.th: raise Exception('Decrease tile height') order = 2 ''' Phase 1: baseline Fully optimize a region in the center of our pano ''' print 'Phase 1: baseline' x0 = (self.icm.width() - self.tw) / 2 if x0 % order != 0: x0 += 1 x1 = x0 + self.tw - 1 y0 = (self.icm.height() - self.th) / 2 if y0 % order != 0: y0 += 1 y1 = y0 + self.th - 1 (center_pto, center_cplis) = self.partial_optimize(x0, x1, y0, y1) merge_pto(center_pto, self.opt_project, center_cplis) ''' Phase 2: predict Now use base center project to predict optimization positions for rest of project Assume that scanning left/right and that backlash will cause rows to alternate ("order 2") Note this will also fill in position estimates for unmatched images x = c0 * c + c1 * r + c2 y = c3 * c + c4 * r + c5 XXX: is there reason to have order 2 y coordinates? ''' print 'Phase 2: predict' ((c0s, c1s, c2s), (c3s, c4s, c5s)) = linearize(self.opt_project, center_pto, allow_missing=False, order=order) # Exclude filenames directly optimized center_is = set() for il in center_pto.get_image_lines(): center_is.add(self.opt_project.i2i(center_pto, il.get_index())) for row in xrange(self.icm.width()): for col in xrange(self.icm.height()): fn = self.icm.get_image(col, row) il = self.project.img_fn2l(fn) # Skip directly optimized lines if il.get_index() in center_is: continue # Otherwise predict position x = c0s[col % order] * col + c1s[col % order] * row + c2s[ col % order] il.set_variable('d', x) y = c3s[row % order] * col + c4s[row % order] * row + c5s[ row % order] il.set_variable('e', y) ''' Phase 3: optimize Moving out from center, optimize sub-sections based off of prediction Move in a cross pattern Left Right Up Down Expand scope ''' ''' x0 = self.icm.width() / 2 if x0 % order != 0: x0 += 1 x1 = x0 + self.tw - 1 y0 = self.icm.height() / 2 if y0 % order != 0: y0 += 1 y1 = y0 + self.th - 1 (center_pto, center_cplis) = self.partial_optimize(x0, x1, y0, y1) merge_pto(center_pto, self.opt_project, center_cplis) ''' if self.debug: print self.project bench.stop() print 'Optimized project in %s' % bench
def init(self): set_debug_width(self.metal.width) set_debug_height(self.metal.height) #print g_width, g_height #sys.exit(1) self.default_layer_names() # Clip as early as possible to avoid extra operations self.clip() self.color_layers() self.metal.index = Layer.METAL if self.metal_gnd: self.metal_gnd.potential = Net.GND self.metal_gnd.index = Layer.METAL if self.metal_vcc: self.metal_vcc.potential = Net.VCC self.metal_vcc.index = Layer.METAL self.polysilicon.index = Layer.POLYSILICON # visual6502 net numbers seem to start at 1, not 0 self.min_net_number = 1 self.transdefs = Transdefs() self.reset_net_number() # Skip some checks before nets are setup, but make the reference availible self.nets = None #self.polygon_nets = dict() self.remove_polygon = self.remove_polygon_no_nets self.vdd = None self.vss = None # Deals with small non-intersecting delta issues, but does distort the result print 'Enlarging layers...' bench = Benchmark() for layer in self.layers: layer.enlarge(None, 1.0) print 'Layers enlarged in %s' % repr(bench) # Must be done before projrection or can result in complex geometries # Well you can still get them, but its much easier if you don't do this first bench = Benchmark() self.condense_polygons() print 'Polygons condensed in %s' % repr(bench) # net to set of polygons # Used for merging nets # number to net object self.nets = Nets() self.remove_polygon = self.remove_polygon_regular if Options.transistors_by_intersect: self.project_diffusion() #print 'Polygons: %d' % len(self.diffusion.polygons) #self.diffusion.show_polygons() #sys.exit(1) #self.diffusion.index = Layer.UNKNOWN_DIFFUSION #self.buried_contacts = Layer(Options.DEFAULT_IMAGE_FILE_BURIED_CONTACTS) #self.transistors = Layer(Options.DEFAULT_IMAGE_FILE_TRANSISTORS) self.transistors = Transistors() self.rebuild_layer_lists() self.verify_layer_sizes_after_load() for layer in self.layers: layer.show()
def try_supertile(self, x0, x1, y0, y1): '''x0/1 and y0/1 are global absolute coordinates''' # First generate all of the valid tiles across this area to see if we can get any useful work done? # every supertile should have at least one solution or the bounds aren't good bench = Benchmark() try: temp_file = ManagedTempFile.get(None, '.tif') bounds = [x0, x1, y0, y1] #out_name_base = "%s/r%03d_c%03d" % (self.out_dir, row, col) #print 'Working on %s' % out_name_base stitcher = PartialStitcher(self.pto, bounds, temp_file.file_name) if self.dry: print 'Dry: skipping partial stitch' stitcher = None else: stitcher.run() print print 'Phase 3: loading supertile image' if self.dry: print 'Dry: skipping loading PTO' img = None else: img = PImage.from_file(temp_file.file_name) print 'Supertile width: %d, height: %d' % (img.width(), img.height()) new = 0 ''' A tile is valid if its in a safe location There are two ways for the location to be safe: -No neighboring tiles as found on canvas edges -Sufficiently inside the blend area that artifacts should be minimal ''' gen_tiles = 0 print # TODO: get the old info back if I miss it after yield refactor print 'Phase 4: chopping up supertile' self.msg('step(x: %d, y: %d)' % (self.tw, self.th), 3) #self.msg('x in xrange(%d, %d, %d)' % (xt0, xt1, self.tw), 3) #self.msg('y in xrange(%d, %d, %d)' % (yt0, yt1, self.th), 3) for (y, x) in self.gen_supertile_tiles(x0, x1, y0, y1): # If we made it this far the tile can be constructed with acceptable enblend artifacts row = self.y2row(y) col = self.x2col(x) # Did we already do this tile? if self.is_done(row, col): # No use repeating it although it would be good to diff some of these print 'Rejecting tile x%d, y%d / r%d, c%d: already done' % (x, y, row, col) continue # note that x and y are in whole pano coords # we need to adjust to our frame # row and col on the other hand are used for global naming self.make_tile(img, x - x0, y - y0, row, col) gen_tiles += 1 bench.stop() print 'Generated %d new tiles for a total of %d / %d in %s' % (gen_tiles, len(self.closed_list), self.net_expected_tiles, str(bench)) if gen_tiles == 0: raise Exception("Didn't generate any tiles") # temp_file should be automatically deleted upon exit except: print 'Supertile failed at %s' % bench raise
def run(self): ''' The base Hugin project seems to work if you take out a few things: Eb1 Eev0 Er1 Ra0 Rb0 Rc0 Rd0 Re0 Va1 Vb0 Vc0 Vd0 Vx-0 Vy-0 So say generate a project file with all of those replaced In particular we will generate new i lines To keep our original object intact we will instead do a diff and replace the optimized things on the old project Output is merged into the original file and starts after a line with a single * Even Hugin wpon't respect this optimization if loaded in as is Gives lines out like this o f0 r0 p0 y0 v51 a0.000000 b0.000000 c0.000000 g-0.000000 t-0.000000 d-0.000000 e-0.000000 u10 -buf These are the lines we care about C i0 c0 x3996.61 y607.045 X3996.62 Y607.039 D1.4009 Dx-1.15133 Dy0.798094 Where D is the magnitutde of the distance and x and y are the x and y differences to fitted solution There are several other lines that are just the repeats of previous lines ''' bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() # Copy project so we can trash it project = self.project.copy() prepare_pto(project, self.reoptimize) pre_run_text = project.get_text() if 0: print print print 'PT optimizer project:' print pre_run_text print print # "PToptimizer out.pto" args = ["PToptimizer"] args.append(project.get_a_file_name()) #project.save() rc = execute.without_output(args) if rc != 0: fn = '/tmp/pr0nstitch.optimizer_failed.pto' print print print 'Failed rc: %d' % rc print 'Failed project save to %s' % (fn, ) try: open(fn, 'w').write(pre_run_text) except: print 'WARNING: failed to write failure' print print raise Exception('failed position optimization') # API assumes that projects don't change under us project.reopen() ''' Line looks like this # final rms error 24.0394 units ''' rms_error = None for l in project.get_comment_lines(): if l.find('final rms error') >= 00: rms_error = float(l.split()[4]) break print 'Optimize: RMS error of %f' % rms_error # Filter out gross optimization problems if self.rms_error_threshold and rms_error > self.rms_error_threshold: raise Exception("Max RMS error threshold %f but got %f" % (self.rms_error_threshold, rms_error)) if self.debug: print 'Parsed: %s' % str(project.parsed) if self.debug: print print print print 'Optimized project:' print project #sys.exit(1) print 'Optimized project parsed: %d' % project.parsed print 'Merging project...' merge_pto(project, self.project) if self.debug: print self.project bench.stop() print 'Optimized project in %s' % bench # These are beyond this scope # Move them somewhere else if we want them if 0: # The following will assume all of the images have the same size self.verify_images() # Final dimensions are determined by field of view and width # Calculate optimial dimensions self.calc_dimensions() print 'Centering project...' self.center_project() ''' WARNING WARNING WARNING The panotools model is too advanced for what I'm doing right now The image correction has its merits but is mostly getting in the way to distort images Therefore, I'd like to complete this to understand the intended use but I suspect its not a good idea and I could do my own nona style program much better The only downside is that if / when I start doing lens model corrections I'll have to rethink this a little Actually, a lot of these problems go away if I trim to a single tile I can use the same FOV as the source image or something similar ''' print 'Calculating optimial field of view to match desired size...' self.calc_fov()
def run(self): print 'Input images width %d, height %d' % (self.img_width, self.img_height) print 'Output to %s' % self.out_dir print 'Super tile width %d, height %d from scalar %d' % (self.stw, self.sth, self.st_scalar_heuristic) print 'Super tile x step %d, y step %d' % (self.super_t_xstep, self.super_t_ystep) print 'Supertile clip width %d, height %d' % (self.clip_width, self.clip_height) if self.merge and self.force: raise Exception('Can not merge and force') if not self.dry: self.dry = True print print print print '***BEGIN DRY RUN***' self.run() print '***END DRY RUN***' print print print self.dry = False if not self.ignore_crop and self.pto.get_panorama_line().getv('S') is None: raise Exception('Not cropped. Set ignore crop to force continue') ''' if we have a width of 256 and 1 pixel we need total size of 256 If we have a width of 256 and 256 pixels we need total size of 256 if we have a width of 256 and 257 pixel we need total size of 512 ''' print 'Tile width: %d, height: %d' % (self.tw, self.th) print 'Net size: %d width (%d:%d) X %d height (%d:%d) = %d MP' % (self.width(), self.left(), self.right(), self.height(), self.top(), self.bottom(), self.width() * self.height() / 1000000) print 'Output image extension: %s' % self.out_extension self.this_tiles_done = 0 bench = Benchmark() # Scrub old dir if we don't want it if os.path.exists(self.out_dir) and not self.merge: if not self.force: raise Exception("Must set force to override output") if not self.dry: shutil.rmtree(self.out_dir) if not self.dry and not os.path.exists(self.out_dir): os.mkdir(self.out_dir) if self.st_dir and not self.dry and not os.path.exists(self.st_dir): os.mkdir(self.st_dir) # in form (row, col) self.closed_list = set() self.n_expected_sts = len(list(self.gen_supertiles())) print 'M: Generating %d supertiles' % self.n_expected_sts x_tiles_ideal = 1.0 * self.width() / self.tw x_tiles = math.ceil(x_tiles_ideal) y_tiles_ideal = 1.0 * self.height() / self.th y_tiles = math.ceil(y_tiles_ideal) self.net_expected_tiles = x_tiles * y_tiles ideal_tiles = x_tiles_ideal * y_tiles_ideal print 'M: Ideal tiles: %0.3f x, %0.3f y tiles => %0.3f net' % ( x_tiles_ideal, y_tiles_ideal, ideal_tiles) print 'M: Expecting to generate x%d, y%d => %d basic tiles' % ( x_tiles, y_tiles, self.net_expected_tiles) if self.merge: self.seed_merge() if self.is_full: print 'M: full => forcing 1 thread ' self.threads = 1 print 'M: Initializing %d workers' % self.threads self.workers = [] for ti in xrange(self.threads): print 'Bringing up W%02d' % ti w = Worker(ti, self, os.path.join(self.log_dir, 'w%02d.log' % ti)) self.workers.append(w) w.start() print print print print 'S' * 80 print 'M: Serial end' print 'P' * 80 try: #temp_file = 'partial.tif' self.n_supertiles = 0 st_gen = self.gen_supertiles() all_allocated = False last_progress = time.time() pair_submit = 0 pair_complete = 0 idle = False while not (all_allocated and pair_complete == pair_submit): progress = False # Check for completed jobs for wi, worker in enumerate(self.workers): try: out = worker.qo.get(False) except Queue.Empty: continue pair_complete += 1 what = out[0] progress = True if what == 'done': (st_bounds, img_fn) = out[1] print 'MW%d: done w/ submit %d, complete %d' % (wi, pair_submit, pair_complete) # Dry run if img_fn is None: pim = None else: pim = PImage.from_file(img_fn) # hack # ugh remove may be an already existing supertile (not a temp file) #os.remove(img_fn) self.process_image(pim, st_bounds) elif what == 'exception': if not self.ignore_errors: for worker in self.workers: worker.running.clear() # let stdout clear up # (only moderately effective) time.sleep(1) #(_task, e) = out[1] print '!' * 80 print 'M: ERROR: MW%d failed w/ exception' % wi (_task, _e, estr) = out[1] print 'M: Stack trace:' for l in estr.split('\n'): print l print '!' * 80 if not self.ignore_errors: raise Exception('M: shutdown on worker failure') print 'M WARNING: continuing despite worker failure' else: print 'M: %s' % (out,) raise Exception('M: internal error: bad task type %s' % what) self.st_limit -= 1 if self.st_limit == 0: print 'Breaking on ST limit reached' break # Any workers need more work? for wi, worker in enumerate(self.workers): if all_allocated: break if worker.qi.empty(): while True: try: st_bounds = st_gen.next() except StopIteration: print 'M: all tasks allocated' all_allocated = True break progress = True [x0, x1, y0, y1] = st_bounds self.n_supertiles += 1 print 'M: checking supertile x(%d:%d) y(%d:%d)' % (x0, x1, y0, y1) if not self.should_try_supertile(st_bounds): print 'M WARNING: skipping supertile %d as it would not generate any new tiles' % self.n_supertiles continue print '*' * 80 #print 'W%d: submit %s (%d / %d)' % (wi, repr(pair), pair_submit, n_pairs) print "Creating supertile %d / %d with x%d:%d, y%d:%d" % (self.n_supertiles, self.n_expected_sts, x0, x1, y0, y1) print 'W%d: submit' % (wi,) worker.qi.put((st_bounds,)) pair_submit += 1 break if progress: last_progress = time.time() idle = False else: if not idle: print 'M Server thread idle' idle = True # can take some time, but should be using smaller tiles now if time.time() - last_progress > 4 * 60 * 60: print 'M WARNING: server thread stalled' last_progress = time.time() time.sleep(0.1) bench.stop() print 'M Processed %d supertiles to generate %d new (%d total) tiles in %s' % (self.n_expected_sts, self.this_tiles_done, self.tiles_done(), str(bench)) tiles_s = self.this_tiles_done / bench.delta_s() print 'M %f tiles / sec, %f pix / sec' % (tiles_s, tiles_s * self.tw * self.th) if self.tiles_done() != self.net_expected_tiles: print 'M ERROR: expected to do %d basic tiles but did %d' % (self.net_expected_tiles, self.tiles_done()) self.dump_open_list() raise Exception('State mismatch') # Gather up supertile filenames generated by workers # xxx: maybe we should tell slaves the file they should use? for worker in self.workers: while True: try: st_fn = worker.st_fns.get(False) except Queue.Empty: break self.st_fns.append(st_fn) finally: self.wkill() self.workers = None
def run(self): ''' The base Hugin project seems to work if you take out a few things: Eb1 Eev0 Er1 Ra0 Rb0 Rc0 Rd0 Re0 Va1 Vb0 Vc0 Vd0 Vx-0 Vy-0 So say generate a project file with all of those replaced In particular we will generate new i lines To keep our original object intact we will instead do a diff and replace the optimized things on the old project Output is merged into the original file and starts after a line with a single * Even Hugin wpon't respect this optimization if loaded in as is Gives lines out like this o f0 r0 p0 y0 v51 a0.000000 b0.000000 c0.000000 g-0.000000 t-0.000000 d-0.000000 e-0.000000 u10 -buf These are the lines we care about C i0 c0 x3996.61 y607.045 X3996.62 Y607.039 D1.4009 Dx-1.15133 Dy0.798094 Where D is the magnitutde of the distance and x and y are the x and y differences to fitted solution There are several other lines that are just the repeats of previous lines ''' bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() # Copy project so we can trash it project = self.project.to_ptoptimizer() prepare_pto(project, self.reoptimize) pre_run_text = project.get_text() if 0: print print print 'PT optimizer project:' print pre_run_text print print # "PToptimizer out.pto" args = list() args.append(project.get_a_file_name()) #project.save() rc = Execute.show_output("PToptimizer", args) if not rc == 0: print print print 'Failed rc: %d' % rc print 'Failed project:' print pre_run_text print print raise Exception('failed position optimization') # API assumes that projects don't change under us project.reopen() ''' Line looks like this # final rms error 24.0394 units ''' rms_error = None for l in project.get_comment_lines(): if l.find('final rms error') >= 00: rms_error = float(l.split()[4]) break print 'Optimize: RMS error of %f' % rms_error # Filter out gross optimization problems if self.rms_error_threshold and rms_error > self.rms_error_threshold: raise Exception("Max RMS error threshold %f but got %f" % (self.rms_error_threshold, rms_error)) if self.debug: print 'Parsed: %s' % str(project.parsed) if self.debug: print print print print 'Optimized project:' print project #sys.exit(1) print 'Optimized project parsed: %d' % project.parsed print 'Merging project...' merge_pto(project, self.project) if self.debug: print self.project bench.stop() print 'Optimized project in %s' % bench # These are beyond this scope # Move them somewhere else if we want them if 0: # The following will assume all of the images have the same size self.verify_images() # Final dimensions are determined by field of view and width # Calculate optimial dimensions self.calc_dimensions() print 'Centering project...' self.center_project() ''' WARNING WARNING WARNING The panotools model is too advanced for what I'm doing right now The image correction has its merits but is mostly getting in the way to distort images Therefore, I'd like to complete this to understand the intended use but I suspect its not a good idea and I could do my own nona style program much better The only downside is that if / when I start doing lens model corrections I'll have to rethink this a little Actually, a lot of these problems go away if I trim to a single tile I can use the same FOV as the source image or something similar ''' print 'Calculating optimial field of view to match desired size...' self.calc_fov()
def run(self): print 'Input images width %d, height %d' % (self.img_width, self.img_height) print 'Output to %s' % self.out_dir print 'Super tile width %d, height %d from scalar %d' % (self.stw, self.sth, self.st_scalar_heuristic) print 'Super tile x step %d, y step %d' % (self.super_t_xstep, self.super_t_ystep) print 'Supertile clip width %d, height %d' % (self.clip_width, self.clip_height) if self.merge and self.force: raise Exception('Can not merge and force') if not self.dry: self.dry = True print print print print '***BEGIN DRY RUN***' self.run() print '***END DRY RUN***' print print print self.dry = False ''' if we have a width of 256 and 1 pixel we need total size of 256 If we have a width of 256 and 256 pixels we need total size of 256 if we have a width of 256 and 257 pixel we need total size of 512 ''' print 'Tile width: %d, height: %d' % (self.tw, self.th) print 'Net size: %d width (%d:%d) X %d height (%d:%d) = %d MP' % (self.width(), self.left(), self.right(), self.height(), self.top(), self.bottom(), self.width() * self.height() / 1000000) print 'Output image extension: %s' % self.out_extension self.this_tiles_done = 0 bench = Benchmark() # Scrub old dir if we don't want it if os.path.exists(self.out_dir) and not self.merge: if self.force: if not self.dry: shutil.rmtree(self.out_dir) else: raise Exception("Must set force to override output") if not self.dry and not os.path.exists(self.out_dir): os.mkdir(self.out_dir) # in form (row, col) self.closed_list = set() self.n_expected_sts = len(list(self.gen_supertiles())) print 'Generating %d supertiles' % self.n_expected_sts x_tiles_ideal = 1.0 * self.width() / self.tw x_tiles = math.ceil(x_tiles_ideal) y_tiles_ideal = 1.0 * self.height() / self.th y_tiles = math.ceil(y_tiles_ideal) self.net_expected_tiles = x_tiles * y_tiles ideal_tiles = x_tiles_ideal * y_tiles_ideal print 'Ideal tiles: %0.3f x, %0.3f y tiles => %0.3f net' % ( x_tiles_ideal, y_tiles_ideal, ideal_tiles) print 'Expecting to generate x%d, y%d => %d basic tiles' % ( x_tiles, y_tiles, self.net_expected_tiles) if self.merge: self.seed_merge() #temp_file = 'partial.tif' self.n_supertiles = 0 for supertile in self.gen_supertiles(): self.n_supertiles += 1 [x0, x1, y0, y1] = supertile print 'Checking supertile x(%d:%d) y(%d:%d)' % (x0, x1, y0, y1) if self.should_try_supertile(x0, x1, y0, y1): print print print "Creating supertile %d / %d with x%d:%d, y%d:%d" % (self.n_supertiles, self.n_expected_sts, x0, x1, y0, y1) try: self.try_supertile(x0, x1, y0, y1) except CommandFailed as e: if self.ignore_errors: # We shouldn't be trying commands during dry but just in case should raise? print 'WARNING: got exception trying supertile %d' % (self.n_supertiles) traceback.print_exc() else: raise else: print 'WARNING: skipping supertile %d as it would not generate any new tiles' % self.n_supertiles bench.stop() print 'Processed %d supertiles to generate %d new (%d total) tiles in %s' % (self.n_expected_sts, self.this_tiles_done, self.tiles_done(), str(bench)) tiles_s = self.this_tiles_done / bench.delta_s() print '%f tiles / sec, %f pix / sec' % (tiles_s, tiles_s * self.tw * self.th) if self.tiles_done() != self.net_expected_tiles: print 'ERROR: expected to do %d basic tiles but did %d' % (self.net_expected_tiles, self.tiles_done()) self.dump_open_list() raise Exception('State mismatch')
class CNCGUI(QMainWindow): cncProgress = pyqtSignal(int, int, str, int) snapshotCaptured = pyqtSignal(int) def __init__(self): QMainWindow.__init__(self) self.cnc_raw = get_cnc() self.cnc_raw.on() self.cnc_ipc = ControllerThread(self.cnc_raw) self.initUI() # Must not be initialized until after layout is set self.gstWindowId = None if config['imager']['engine'] == 'gstreamer': self.source = gst.element_factory_make("v4l2src", "vsource") self.source.set_property("device", "/dev/video0") self.setupGst() elif config['imager']['engine'] == 'gstreamer-testsrc': self.source = gst.element_factory_make("videotestsrc", "video-source") self.setupGst() self.cnc_ipc.start() # Offload callback to GUI thread so it can do GUI ops self.cncProgress.connect(self.processCncProgress) if self.cnc_raw is None: dbg("Disabling all motion controls on no CNC") self.setControlsEnabled(False) if self.gstWindowId: dbg("Starting gstreamer pipeline") self.player.set_state(gst.STATE_PLAYING) if config['cnc']['startup_run']: self.run() def x(self, n): self.axes['X'].jog(n) def y(self, n): self.axes['Y'].jog(n) def z(self, n): self.axes['Z'].jog(n) def reload_obj_cb(self): '''Re-populate the objective combo box''' self.obj_cb.clear() self.obj_config = None for objective in config['objective']: self.obj_cb.addItem(objective['name']) def update_obj_config(self): '''Make resolution display reflect current objective''' self.obj_config = config['objective'][self.obj_cb.currentIndex ()] print 'Selected objective %s' % self.obj_config['name'] self.obj_mag.setText('Magnification: %0.2f' % self.obj_config["mag"]) self.obj_x_view.setText('X view (um): %0.3f' % self.obj_config["x_view"]) self.obj_y_view.setText('Y view (um): %0.3f' % self.obj_config["y_view"]) def get_config_layout(self): cl = QGridLayout() row = 0 l = QLabel("Objective") cl.addWidget(l, row, 0) self.obj_cb = QComboBox() cl.addWidget(self.obj_cb, row, 1) self.obj_cb.currentIndexChanged.connect(self.update_obj_config) row += 1 self.obj_mag = QLabel("") cl.addWidget(self.obj_mag, row, 1) self.obj_x_view = QLabel("") row += 1 cl.addWidget(self.obj_x_view, row, 1) self.obj_y_view = QLabel("") cl.addWidget(self.obj_y_view, row, 2) row += 1 # seed it self.reload_obj_cb() self.update_obj_config() return cl def get_video_layout(self): # Overview def low_res_layout(): layout = QVBoxLayout() layout.addWidget(QLabel("Overview")) # Raw X-windows canvas self.video_container = QWidget() # Allows for convenient keyboard control by clicking on the video self.video_container.setFocusPolicy(Qt.ClickFocus) # TODO: do something more proper once integrating vodeo feed w, h = 800, 600 w, h = 3264/8, 2448/8 self.video_container.setMinimumSize(w, h) self.video_container.resize(w, h) policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.video_container.setSizePolicy(policy) layout.addWidget(self.video_container) return layout # Higher res in the center for focusing def high_res_layout(): layout = QVBoxLayout() layout.addWidget(QLabel("Focus")) # Raw X-windows canvas self.video_container2 = QWidget() # TODO: do something more proper once integrating vodeo feed w, h = 800, 600 w, h = 3264/8, 2448/8 self.video_container2.setMinimumSize(w, h) self.video_container2.resize(w, h) policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.video_container2.setSizePolicy(policy) layout.addWidget(self.video_container2) return layout layout = QHBoxLayout() layout.addLayout(low_res_layout()) layout.addLayout(high_res_layout()) return layout def setupGst(self): ''' gst-launch v4l2src device=/dev/video0 ! tee ! queue ! videoscale ! capsfilter caps=video/x-raw-yuv ! xvimagesink gst-launch v4l2src device=/dev/video0 ! videoscale ! xvimagesink gst-launch v4l2src device=/dev/video0 ! ffmpegcolorspace ! ximagesink works...hmm gst-launch v4l2src device=/dev/video0 ! ffmpegcolorspace ! videocrop top=100 left=1 right=4 bottom=0 ! ximagesink sysctl kernel.shmmax=67108864 cranked up to 128M, no change er no that was in KB so that was 128GB... sysctl kernel.shmall=32768 didn't try messing with this kernel.shmall = 2097152 2GB, should be plenty sysctl kernel.shmmax=67108864 default: 33554432 sysctl kernel.shmall=32768 default: 2097152 Default IPC limits root@gespenst:/home/mcmaster# ipcs -l ------ Shared Memory Limits -------- max number of segments = 4096 max seg size (kbytes) = 32768 max total shared memory (kbytes) = 8388608 min seg size (bytes) = 1 ------ Semaphore Limits -------- max number of arrays = 128 max semaphores per array = 250 max semaphores system wide = 32000 max ops per semop call = 32 semaphore max value = 32767 ------ Messages Limits -------- max queues system wide = 1471 max size of message (bytes) = 8192 default max size of queue (by Works fine at med res mcmaster@gespenst:~/document/external/pr0ntools/cnc_microscope/snapshot$ gst-launch v4l2src device=/dev/video0 ! videoscale ! xvimagesink Setting pipeline to PAUSED ... Pipeline is live and does not need PREROLL ... Setting pipeline to PLAYING ... New clock: GstSystemClock (close window) ERROR: from element /GstPipeline:pipeline0/GstXvImageSink:xvimagesink0: Output window was closed Additional debug info: xvimagesink.c(1326): gst_xvimagesink_handle_xevents (): /GstPipeline:pipeline0/GstXvImageSink:xvimagesink0 Execution ended after 2888164132 ns. Setting pipeline to PAUSED ... Setting pipeline to READY ... Setting pipeline to NULL ... Freeing pipeline ... Dies at high res mcmaster@gespenst:~/document/external/pr0ntools/cnc_microscope/snapshot$ gst-launch v4l2src device=/dev/video0 ! videoscale ! xvimagesink Setting pipeline to PAUSED ... Pipeline is live and does not need PREROLL ... Setting pipeline to PLAYING ... New clock: GstSystemClock ERROR: from element /GstPipeline:pipeline0/GstXvImageSink:xvimagesink0: Failed to create output image buffer of 3264x2448 pixels Additional debug info: xvimagesink.c(2404): gst_xvimagesink_show_frame (): /GstPipeline:pipeline0/GstXvImageSink:xvimagesink0: XServer allocated buffer size did not match input buffer Execution ended after 1854135991 ns. Setting pipeline to PAUSED ... Setting pipeline to READY ... Setting pipeline to NULL ... Freeing pipeline ... On Fedora I had to do something like vmalloc=192M, related? ''' dbg("Setting up gstreamer pipeline") self.gstWindowId = self.video_container.winId() self.gstWindowId2 = self.video_container2.winId() self.player = gst.Pipeline("player") #sinkxv = gst.element_factory_make("xvimagesink") sinkx = gst.element_factory_make("ximagesink", 'sinkx_overview') sinkx_focus = gst.element_factory_make("ximagesink", 'sinkx_focus') #fvidscale_cap = gst.element_factory_make("capsfilter") #fvidscale = gst.element_factory_make("videoscale") fcs = gst.element_factory_make('ffmpegcolorspace') caps = gst.caps_from_string('video/x-raw-yuv') #fvidscale_cap.set_property('caps', caps) self.stream_queue = gst.element_factory_make("queue") self.tee = gst.element_factory_make("tee") self.capture_enc = gst.element_factory_make("jpegenc") self.capture_sink = gst.element_factory_make("capturesink") #self.resizer = gst.element_factory_make("myresize") self.resizer = gst.element_factory_make("videoscale") self.snapshotCaptured.connect(self.captureSnapshot) self.capture_sink_queue = gst.element_factory_make("queue") ''' Per #gstreamer question evidently v4l2src ! ffmpegcolorspace ! ximagesink gst-launch v4l2src ! ffmpegcolorspace ! ximagesink allocates memory different than v4l2src ! videoscale ! xvimagesink gst-launch v4l2src ! videoscale ! xvimagesink Problem is that the former doesn't resize the window but allows taking full res pictures The later resizes the window but doesn't allow taking full res pictures However, we don't want full res in the view window ''' # works at lower res and resizes #self.player.add(fvidscale, sinkxv) # what was this being used for? self.player.add(self.source, self.tee, self.stream_queue) # works at full res but doesn't resize #self.player.add(fcs, sinkx) # compromise self.player.add(fcs, self.resizer, sinkx, sinkx_focus) self.player.add(self.capture_sink_queue, self.capture_enc, self.capture_sink) # Video render stream gst.element_link_many(self.source, self.tee) #gst.element_link_many(self.tee, self.stream_queue, fvidscale, fvidscale_cap, sinkxv) self.size_tee = gst.element_factory_make("tee") self.size_queue_overview = gst.element_factory_make("queue") self.size_queue_focus = gst.element_factory_make("queue") # First lets make this identical to keep things simpler self.videocrop = gst.element_factory_make("videocrop") ''' TODO: make this more automagic w, h = 3264/8, 2448/8 => 408, 306 Want 3264/2, 2448,2 type resolution Image is coming in raw at this point which menas we need to end up with 408*2, 306*2 => 816, 612 since its centered crop the same amount off the top and bottom: (3264 - 816)/2, (2448 - 612)/2 => 1224, 918 ''' self.videocrop.set_property("top", 918) self.videocrop.set_property("bottom", 918) self.videocrop.set_property("left", 1224) self.videocrop.set_property("right", 1224) self.scale2 = gst.element_factory_make("videoscale") self.player.add(self.size_tee, self.size_queue_overview, self.size_queue_focus, self.videocrop, self.scale2) gst.element_link_many(self.tee, self.stream_queue, fcs, self.size_tee) gst.element_link_many(self.size_tee, self.size_queue_overview, self.resizer, sinkx) # gah # libv4l2: error converting / decoding frame data: v4l-convert: error destination buffer too small (16777216 < 23970816) gst.element_link_many(self.size_tee, self.size_queue_focus, self.videocrop, self.scale2, sinkx_focus) #self.resizer_temp = gst.element_factory_make("myresize") #self.player.add(self.resizer_temp) #gst.element_link_many(self.size_tee, self.size_queue_focus, self.scale2, sinkx_focus) # Frame grabber stream gst.element_link_many(self.tee, self.capture_sink_queue, self.capture_enc, self.capture_sink) bus = self.player.get_bus() bus.add_signal_watch() bus.enable_sync_message_emission() bus.connect("message", self.on_message) bus.connect("sync-message::element", self.on_sync_message) def on_message(self, bus, message): t = message.type if t == gst.MESSAGE_EOS: self.player.set_state(gst.STATE_NULL) print "End of stream" elif t == gst.MESSAGE_ERROR: err, debug = message.parse_error() print "Error: %s" % err, debug self.player.set_state(gst.STATE_NULL) else: #print 'Other message: %s' % t # Deadlocks upon calling this... #print 'Cur state %s' % self.player.get_state() '' def on_sync_message(self, bus, message): if message.structure is None: return message_name = message.structure.get_name() if message_name == "prepare-xwindow-id": if message.src.get_name() == 'sinkx_overview': win_id = self.gstWindowId elif message.src.get_name() == 'sinkx_focus': win_id = self.gstWindowId2 else: raise Exception('oh noes') assert win_id imagesink = message.src imagesink.set_xwindow_id(win_id) def home(self): dbg('home requested') self.cnc_ipc.home() def go_rel(self): dbg('Go rel all requested') for k in self.axes: axis = self.axes[k] axis.go_rel() def go_abs(self): dbg('Go abs all requested') for k in self.axes: axis = self.axes[k] axis.go_abs() def processCncProgress(self, pictures_to_take, pictures_taken, image, first): print 'Processing CNC progress' if first: print 'First CB with %d items' % pictures_to_take self.pb.setMinimum(0) self.pb.setMaximum(pictures_to_take) self.bench = Benchmark(pictures_to_take) else: print 'took %s at %d / %d' % (image, pictures_taken, pictures_to_take) self.bench.set_cur_items(pictures_taken) print self.bench self.pb.setValue(pictures_taken) def dry(self): return self.dry_cb.isChecked() def run(self): if not self.snapshot_pb.isEnabled(): print "Wait for snapshot to complete before CNC'ing" return dry = self.dry() if dry: dbg('Dry run checked') rconfig = RunConfig() imager = None if not dry: print 'Loading imager...' itype = config['imager']['engine'] if itype == 'mock': imager = MockImager() elif itype == "VC": if VCImager is None: raise Exception('Import failed') imager = VCImager() elif itype == 'gstreamer' or itype == 'gstreamer-testsrc': class GstImager(Imager): def __init__(self, gui): Imager.__init__(self) self.gui = gui self.image_ready = threading.Event() self.image_id = None def take_picture(self, file_name_out = None): print 'gstreamer imager: taking image to %s' % file_name_out def emitSnapshotCaptured(image_id): print 'Image captured reported: %s' % image_id self.image_id = image_id self.image_ready.set() self.image_id = None self.image_ready.clear() self.gui.capture_sink.request_image(emitSnapshotCaptured) print 'Waiting for next image...' self.image_ready.wait() print 'Got image %s' % self.image_id image = PImage.from_image(self.gui.capture_sink.pop_image(self.image_id)) factor = float(config['imager']['scalar']) # Use a reasonably high quality filter scaled = image.get_scaled(factor, Image.ANTIALIAS) if not self.gui.dry(): scaled.save(file_name_out) imager = GstImager(self) else: raise Exception('Invalid imager type %s' % itype) if not config: raise Exception("missing uscope config") if not self.obj_config: raise Exception("missing obj config") rconfig.dry = dry def emitCncProgress(pictures_to_take, pictures_taken, image, first): print 'Emitting CNC progress' if image is None: image = '' self.cncProgress.emit(pictures_to_take, pictures_taken, image, first) rconfig.progress_cb = emitCncProgress rconfig.obj_config = self.obj_config # Will be offloaded to its own thread # Operations must be blocking # We enforce that nothing is running and disable all CNC GUI controls rconfig.controller = self.cnc_raw rconfig.imager = imager rconfig.job_name = str(self.job_name_le.text()) if len(rconfig.job_name) == 0: rconfig.job_name = "out" if not dry and os.path.exists(rconfig.job_name): raise Exception("job name dir %s already exists" % rconfig.job_name) # If user had started some movement before hitting run wait until its done dbg("Waiting for previous movement (if any) to cease") self.cnc_ipc.wait_idle() self.pt = PlannerThread(self, rconfig) self.pt.plannerDone.connect(self.plannerDone) self.setControlsEnabled(False) #eeeee not working as well as I hoped # tracked it down to python video capture library operating on windows GUI frame buffer # now that switching over to Linux should be fine to be multithreaded # If need to use the old layer again should use signals to block GUI for minimum time if config['multithreaded']: dbg("Running multithreaded") self.pt.start() else: dbg("Running single threaded") self.pt.run() def setControlsEnabled(self, yes): self.go_pb.setEnabled(yes) self.go_abs_pb.setEnabled(yes) self.go_rel_pb.setEnabled(yes) self.snapshot_pb.setEnabled(yes) def plannerDone(self): print 'RX planner done' # Cleanup camera objects self.pt = None self.setControlsEnabled(True) if config['cnc']['startup_run_exit']: print 'Planner debug break on completion' os._exit(1) def stop(self): '''Stop operations after the next operation''' for axis in self.cnc_ipc.axes: axis.stop() def estop(self): '''Stop operations immediately. Position state may become corrupted''' for axis in self.cnc_ipc.axes: axis.estop() def clear_estop(self): '''Stop operations immediately. Position state may become corrupted''' for axis in self.cnc_ipc.axes: axis.unestop() def get_axes_layout(self): layout = QHBoxLayout() gb = QGroupBox('Axes') def get_general_layout(): layout = QVBoxLayout() def get_go(): layout = QHBoxLayout() self.home_pb = QPushButton("Home all") self.home_pb.clicked.connect(self.home) layout.addWidget(self.home_pb) self.go_abs_pb = QPushButton("Go abs all") self.go_abs_pb.clicked.connect(self.go_abs) layout.addWidget(self.go_abs_pb) self.go_rel_pb = QPushButton("Go rel all") self.go_rel_pb.clicked.connect(self.go_rel) layout.addWidget(self.go_rel_pb) return layout def get_stop(): layout = QHBoxLayout() self.stop_pb = QPushButton("Stop") self.stop_pb.clicked.connect(self.stop) layout.addWidget(self.stop_pb) self.estop_pb = QPushButton("Emergency stop") self.estop_pb.clicked.connect(self.estop) layout.addWidget(self.estop_pb) self.clear_estop_pb = QPushButton("Clear e-stop") self.clear_estop_pb.clicked.connect(self.clear_estop) layout.addWidget(self.clear_estop_pb) return layout layout.addLayout(get_go()) layout.addLayout(get_stop()) return layout layout.addLayout(get_general_layout()) self.axes = dict() print 'Axes: %u' % len(self.cnc_ipc.axes) for axis in self.cnc_ipc.axes: if axis.name == 'Z': continue axisw = Axis(axis) print 'Creating axis GUI %s' % axis.name self.axes[axis.name] = axisw layout.addWidget(axisw) gb.setLayout(layout) return gb def get_snapshot_layout(self): gb = QGroupBox('Snapshot') layout = QGridLayout() snapshot_dir = config['imager']['snapshot_dir'] if not os.path.isdir(snapshot_dir): print 'Snapshot dir %s does not exist' % snapshot_dir if os.path.exists(snapshot_dir): raise Exception("Snapshot directory is not accessible") os.mkdir(snapshot_dir) print 'Snapshot dir %s created' % snapshot_dir # nah...just have it in the config # d = QFileDialog.getExistingDirectory(self, 'Select snapshot directory', snapshot_dir) layout.addWidget(QLabel('File name'), 0, 0) self.snapshot_serial = -1 self.snapshot_fn_le = QLineEdit('') self.snapshot_next_serial() layout.addWidget(self.snapshot_fn_le, 0, 1) self.snapshot_pb = QPushButton("Snapshot") self.snapshot_pb.clicked.connect(self.take_snapshot) layout.addWidget(self.snapshot_pb, 1, 0, 2, 1) gb.setLayout(layout) return gb def snapshot_next_serial(self): while True: self.snapshot_serial += 1 fn_base = 'snapshot00%u.jpg' % self.snapshot_serial fn_full = os.path.join(config['imager']['snapshot_dir'], fn_base) if os.path.exists(fn_full): print 'Snapshot %s already exists, skipping' % fn_full continue # Omit base to make GUI easier to read self.snapshot_fn_le.setText(fn_base) break def take_snapshot(self): print 'Requesting snapshot' # Disable until snapshot is completed self.snapshot_pb.setEnabled(False) def emitSnapshotCaptured(image_id): print 'Image captured: %s' % image_id self.snapshotCaptured.emit(image_id) self.capture_sink.request_image(emitSnapshotCaptured) def captureSnapshot(self, image_id): print 'RX image for saving' image = PImage.from_image(self.capture_sink.pop_image(image_id)) fn_full = os.path.join(config['imager']['snapshot_dir'], str(self.snapshot_fn_le.text())) factor = float(config['imager']['scalar']) # Use a reasonably high quality filter image.get_scaled(factor, Image.ANTIALIAS).save(fn_full) # That image is done, get read for the next self.snapshot_next_serial() self.snapshot_pb.setEnabled(True) def get_scan_layout(self): gb = QGroupBox('Scan') layout = QGridLayout() # TODO: add overlap widgets layout.addWidget(QLabel('Job name'), 0, 0) self.job_name_le = QLineEdit('default') layout.addWidget(self.job_name_le, 0, 1) self.go_pb = QPushButton("Go") self.go_pb.clicked.connect(self.run) layout.addWidget(self.go_pb, 1, 0) self.pb = QProgressBar() layout.addWidget(self.pb, 1, 1) layout.addWidget(QLabel('Dry?'), 2, 0) self.dry_cb = QCheckBox() self.dry_cb.setChecked(config['cnc']['dry']) layout.addWidget(self.dry_cb, 2, 1) gb.setLayout(layout) return gb def get_bottom_layout(self): layout = QHBoxLayout() layout.addWidget(self.get_axes_layout()) def get_lr_layout(): layout = QVBoxLayout() layout.addWidget(self.get_snapshot_layout()) layout.addWidget(self.get_scan_layout()) return layout layout.addLayout(get_lr_layout()) return layout def initUI(self): self.setGeometry(300, 300, 250, 150) self.setWindowTitle('pr0ncnc') # top layout layout = QVBoxLayout() layout.addLayout(self.get_config_layout()) layout.addLayout(self.get_video_layout()) layout.addLayout(self.get_bottom_layout()) w = QWidget() w.setLayout(layout) self.setCentralWidget(w) self.show() def keyPressEvent(self, event): ''' Upper left hand coordinate system ''' # Only control explicitly, don't move by typing accident in other element if not self.video_container.hasFocus(): return k = event.key() # Ignore duplicates, want only real presses if event.isAutoRepeat(): return #inc = 5 if k == Qt.Key_Left: dbg('left') if self.axes['X'].jogging: return self.axes['X'].jogging = True self.axes['X'].axis.forever_neg() elif k == Qt.Key_Right: dbg('right') if self.axes['X'].jogging: return self.axes['X'].jogging = True self.axes['X'].axis.forever_pos() elif k == Qt.Key_Up: if self.axes['Y'].jogging: return self.axes['Y'].jogging = True self.axes['Y'].axis.forever_neg() elif k == Qt.Key_Down: if self.axes['Y'].jogging: return self.axes['Y'].jogging = True self.axes['Y'].axis.forever_pos() # Focus is sensitive...should step slower? # worry sonce focus gets re-integrated elif k == Qt.Key_PageDown: if self.axes['Z'].jogging: return self.axes['Z'].jogging = True self.axes['Z'].axis.forever_neg() elif k == Qt.Key_PageUp: if self.axes['Z'].jogging: return self.axes['Z'].jogging = True self.axes['Z'].axis.forever_pos() elif k == Qt.Key_Escape: self.stop() def keyReleaseEvent(self, event): if not self.video_container.hasFocus(): return k = event.key() # Ignore duplicates, want only real presses if event.isAutoRepeat(): return #inc = 5 if k == Qt.Key_Left: dbg('left release') self.axes['X'].axis.stop() self.axes['X'].jogging = False self.axes['X'].emit_pos() elif k == Qt.Key_Right: dbg('right release') self.axes['X'].axis.stop() self.axes['X'].jogging = False self.axes['X'].emit_pos() elif k == Qt.Key_Up: self.axes['Y'].axis.stop() self.axes['Y'].jogging = False self.axes['Y'].emit_pos() elif k == Qt.Key_Down: self.axes['Y'].axis.stop() self.axes['Y'].jogging = False self.axes['Y'].emit_pos() elif k == Qt.Key_PageDown: self.axes['Z'].axis.stop() self.axes['Z'].jogging = False self.axes['Z'].emit_pos() elif k == Qt.Key_PageUp: self.axes['Z'].axis.stop() self.axes['Z'].jogging = False self.axes['Z'].emit_pos()
def run(self): print 'Input images width %d, height %d' % (self.img_width, self.img_height) print 'Output to %s' % self.out_dir print 'Super tile width %d, height %d from scalar %d' % ( self.stw, self.sth, self.st_scalar_heuristic) print 'Super tile x step %d, y step %d' % (self.super_t_xstep, self.super_t_ystep) print 'Supertile clip width %d, height %d' % (self.clip_width, self.clip_height) if self.merge and self.force: raise Exception('Can not merge and force') if not self.dry: self.dry = True print print print print '***BEGIN DRY RUN***' self.run() print '***END DRY RUN***' print print print self.dry = False if not self.ignore_crop and self.pto.get_panorama_line().getv( 'S') is None: raise Exception('Not cropped. Set ignore crop to force continue') ''' if we have a width of 256 and 1 pixel we need total size of 256 If we have a width of 256 and 256 pixels we need total size of 256 if we have a width of 256 and 257 pixel we need total size of 512 ''' print 'Tile width: %d, height: %d' % (self.tw, self.th) print 'Net size: %d width (%d:%d) X %d height (%d:%d) = %d MP' % ( self.width(), self.left(), self.right(), self.height(), self.top(), self.bottom(), self.width() * self.height() / 1000000) print 'Output image extension: %s' % self.out_extension self.this_tiles_done = 0 bench = Benchmark() # Scrub old dir if we don't want it if os.path.exists(self.out_dir) and not self.merge: if not self.force: raise Exception("Must set force to override output") if not self.dry: shutil.rmtree(self.out_dir) if not self.dry and not os.path.exists(self.out_dir): os.mkdir(self.out_dir) if self.st_dir and not self.dry and not os.path.exists(self.st_dir): os.mkdir(self.st_dir) # in form (row, col) self.closed_list = set() self.n_expected_sts = len(list(self.gen_supertiles())) print 'M: Generating %d supertiles' % self.n_expected_sts x_tiles_ideal = 1.0 * self.width() / self.tw x_tiles = math.ceil(x_tiles_ideal) y_tiles_ideal = 1.0 * self.height() / self.th y_tiles = math.ceil(y_tiles_ideal) self.net_expected_tiles = x_tiles * y_tiles ideal_tiles = x_tiles_ideal * y_tiles_ideal print 'M: Ideal tiles: %0.3f x, %0.3f y tiles => %0.3f net' % ( x_tiles_ideal, y_tiles_ideal, ideal_tiles) print 'M: Expecting to generate x%d, y%d => %d basic tiles' % ( x_tiles, y_tiles, self.net_expected_tiles) if self.merge: self.seed_merge() if self.is_full: print 'M: full => forcing 1 thread ' self.threads = 1 print 'M: Initializing %d workers' % self.threads self.workers = [] for ti in xrange(self.threads): print 'Bringing up W%02d' % ti w = Worker(ti, self, os.path.join(self.log_dir, 'w%02d.log' % ti)) self.workers.append(w) w.start() print print print print 'S' * 80 print 'M: Serial end' print 'P' * 80 try: #temp_file = 'partial.tif' self.n_supertiles = 0 st_gen = self.gen_supertiles() all_allocated = False last_progress = time.time() pair_submit = 0 pair_complete = 0 idle = False while not (all_allocated and pair_complete == pair_submit): progress = False # Check for completed jobs for wi, worker in enumerate(self.workers): try: out = worker.qo.get(False) except Queue.Empty: continue pair_complete += 1 what = out[0] progress = True if what == 'done': (st_bounds, img_fn) = out[1] print 'MW%d: done w/ submit %d, complete %d' % ( wi, pair_submit, pair_complete) # Dry run if img_fn is None: pim = None else: pim = PImage.from_file(img_fn) # hack # ugh remove may be an already existing supertile (not a temp file) #os.remove(img_fn) self.process_image(pim, st_bounds) elif what == 'exception': if not self.ignore_errors: for worker in self.workers: worker.running.clear() # let stdout clear up # (only moderately effective) time.sleep(1) #(_task, e) = out[1] print '!' * 80 print 'M: ERROR: MW%d failed w/ exception' % wi (_task, _e, estr) = out[1] print 'M: Stack trace:' for l in estr.split('\n'): print l print '!' * 80 if not self.ignore_errors: raise Exception('M: shutdown on worker failure') print 'M WARNING: continuing despite worker failure' else: print 'M: %s' % (out, ) raise Exception('M: internal error: bad task type %s' % what) self.st_limit -= 1 if self.st_limit == 0: print 'Breaking on ST limit reached' break # Any workers need more work? for wi, worker in enumerate(self.workers): if all_allocated: break if worker.qi.empty(): while True: try: st_bounds = st_gen.next() except StopIteration: print 'M: all tasks allocated' all_allocated = True break progress = True [x0, x1, y0, y1] = st_bounds self.n_supertiles += 1 print 'M: checking supertile x(%d:%d) y(%d:%d)' % ( x0, x1, y0, y1) if not self.should_try_supertile(st_bounds): print 'M WARNING: skipping supertile %d as it would not generate any new tiles' % self.n_supertiles continue print '*' * 80 #print 'W%d: submit %s (%d / %d)' % (wi, repr(pair), pair_submit, n_pairs) print "Creating supertile %d / %d with x%d:%d, y%d:%d" % ( self.n_supertiles, self.n_expected_sts, x0, x1, y0, y1) print 'W%d: submit' % (wi, ) worker.qi.put((st_bounds, )) pair_submit += 1 break if progress: last_progress = time.time() idle = False else: if not idle: print 'M Server thread idle' idle = True # can take some time, but should be using smaller tiles now if time.time() - last_progress > 4 * 60 * 60: print 'M WARNING: server thread stalled' last_progress = time.time() time.sleep(0.1) bench.stop() print 'M Processed %d supertiles to generate %d new (%d total) tiles in %s' % ( self.n_expected_sts, self.this_tiles_done, self.tiles_done(), str(bench)) tiles_s = self.this_tiles_done / bench.delta_s() print 'M %f tiles / sec, %f pix / sec' % (tiles_s, tiles_s * self.tw * self.th) if self.tiles_done() != self.net_expected_tiles: print 'M ERROR: expected to do %d basic tiles but did %d' % ( self.net_expected_tiles, self.tiles_done()) self.dump_open_list() raise Exception('State mismatch') # Gather up supertile filenames generated by workers # xxx: maybe we should tell slaves the file they should use? for worker in self.workers: while True: try: st_fn = worker.st_fns.get(False) except Queue.Empty: break self.st_fns.append(st_fn) finally: self.wkill() self.workers = None
def run(self): if self.dry: print 'Dry run abort' return bench = Benchmark() if not self.output_project_file_name: raise Exception("need project file") #if not self.output_project_file_name: #self.project_temp_file = ManagedTempFile.get() #self.output_project_file_name = self.project_temp_file.file_name print 'Beginning stitch' print 'output project file name: %s' % self.output_project_file_name #sys.exit(1) self.init_failures() # Generate control points and merge them into a master project self.control_point_gen = get_cp_engine() # How many rows and cols to go to each side # If you hand took the pictures, this might suit you self.project = PTOProject.from_blank() if self.output_project_file_name: self.project.set_file_name(self.output_project_file_name) if os.path.exists(self.output_project_file_name): # Otherwise, we merge into it print 'WARNING: removing old project file: %s' % self.output_project_file_name os.remove(self.output_project_file_name) else: self.project.get_a_file_name(None, "_master.pto") self.project.image_file_names = self.image_file_names try: ''' Generate control points ''' self.generate_control_points() print 'Soften try: %s' % (self.soften_try, ) print 'Soften ok: %s' % (self.soften_ok, ) print 'Post stitch fixup...' optimize_xy_only(self.project) fixup_i_lines(self.project) fixup_p_lines(self.project) print print '***PTO project baseline final (%s / %s) data length %d***' % ( self.project.file_name, self.output_project_file_name, len(self.project.get_text())) print self.failure_json_w() print # Make dead sure its saved up to date self.project.save() # having issues with this.. if self.output_project_file_name and not self.project.file_name == self.output_project_file_name: raise Exception('project file name changed %s %s', self.project.file_name, self.output_project_file_name) # TODO: missing calc opt size/width/height/fov and crop except Exception as e: sys.stdout.flush() sys.stderr.flush() print print 'WARNING: stitch FAILED' traceback.print_exc() try: fn = self.project.file_name + ".failed" print 'Attempting to save intermediate result to %s' % fn self.project.save_as(fn) except: print 'WARNING: failed intermediate save' raise e finally: bench.stop() print 'Stitch done in %s' % bench
def try_supertile(self, st_bounds): '''x0/1 and y0/1 are global absolute coordinates''' # First generate all of the valid tiles across this area to see if we can get any useful work done? # every supertile should have at least one solution or the bounds aren't good x0, x1, y0, y1 = st_bounds bench = Benchmark() try: if self.st_dir: # nah...tiff takes up too much space dst = os.path.join(self.st_dir, 'st_%06dx_%06dy.jpg' % (x0, y0)) if os.path.exists(dst): # normally this is a .tif so slight loss in quality img = PImage.from_file(dst) print 'supertile short circuit on already existing: %s' % ( dst, ) return img # st_081357x_000587y.jpg temp_file = ManagedTempFile.get(None, '.tif', prefix_mangle='st_%06dx_%06dy_' % (x0, y0)) stitcher = PartialStitcher(self.pto, st_bounds, temp_file.file_name, self.i, self.running, pprefix=self.pprefix) stitcher.enblend_lock = self.enblend_lock stitcher.nona_args = self.nona_args stitcher.enblend_args = self.enblend_args if self.dry: print 'dry: skipping partial stitch' stitcher = None else: stitcher.run() print print 'phase 3: loading supertile image' if self.dry: print 'dry: skipping loading PTO' img_fn = None else: if self.st_dir: self.st_fns.put(dst) #shutil.copyfile(temp_file.file_name, dst) args = [ 'convert', '-quality', '90', temp_file.file_name, dst ] print 'going to execute: %s' % (args, ) subp = subprocess.Popen(args, stdout=None, stderr=None, shell=False) subp.communicate() if subp.returncode != 0: raise Exception('Failed to copy stitched file') # having some problems that looks like file isn't getting written to disk # monitoring for such errors # remove if I can root cause the source of these glitches for i in xrange(30): if os.path.exists(dst): break if i == 0: print 'WARNING: soften missing strong blur dest file name %s, waiting a bit...' % ( dst, ) time.sleep(0.1) else: raise Exception( 'Missing soften strong blur output file name %s' % dst) # FIXME: was passing loaded image object # Directory should delete on exit # otherwise parent can delete it #img = PImage.from_file(temp_file.file_name) img_fn = temp_file.file_name # prevent deletion temp_file.file_name = '' #print 'supertile width: %d, height: %d' % (img.width(), img.height()) print 'Supertile done w/ fn %s' % (img_fn, ) return img_fn except: print 'supertile failed at %s' % (bench, ) raise
def run(self): ''' The base Hugin project seems to work if you take out a few things: Eb1 Eev0 Er1 Ra0 Rb0 Rc0 Rd0 Re0 Va1 Vb0 Vc0 Vd0 Vx-0 Vy-0 So say generate a project file with all of those replaced In particular we will generate new i lines To keep our original object intact we will instead do a diff and replace the optimized things on the old project Output is merged into the original file and starts after a line with a single * Even Hugin wpon't respect this optimization if loaded in as is Gives lines out like this o f0 r0 p0 y0 v51 a0.000000 b0.000000 c0.000000 g-0.000000 t-0.000000 d-0.000000 e-0.000000 u10 -buf These are the lines we care about C i0 c0 x3996.61 y607.045 X3996.62 Y607.039 D1.4009 Dx-1.15133 Dy0.798094 Where D is the magnitutde of the distance and x and y are the x and y differences to fitted solution There are several other lines that are just the repeats of previous lines ''' bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() # Copy project so we can trash it project = self.project.copy() prepare_pto(project, self.reoptimize) pre_run_text = project.get_text() if 0: print print print 'PT optimizer project:' print pre_run_text print print # "PToptimizer out.pto" args = ["PToptimizer"] args.append(project.get_a_file_name()) #project.save() rc = execute.without_output(args) if rc != 0: fn = '/tmp/pr0nstitch.optimizer_failed.pto' print print print 'Failed rc: %d' % rc print 'Failed project save to %s' % (fn,) try: open(fn, 'w').write(pre_run_text) except: print 'WARNING: failed to write failure' print print raise Exception('failed position optimization') # API assumes that projects don't change under us project.reopen() ''' Line looks like this # final rms error 24.0394 units ''' rms_error = None for l in project.get_comment_lines(): if l.find('final rms error') >= 00: rms_error = float(l.split()[4]) break print 'Optimize: RMS error of %f' % rms_error # Filter out gross optimization problems if self.rms_error_threshold and rms_error > self.rms_error_threshold: raise Exception("Max RMS error threshold %f but got %f" % (self.rms_error_threshold, rms_error)) if self.debug: print 'Parsed: %s' % str(project.parsed) if self.debug: print print print print 'Optimized project:' print project #sys.exit(1) print 'Optimized project parsed: %d' % project.parsed print 'Merging project...' merge_pto(project, self.project) if self.debug: print self.project bench.stop() print 'Optimized project in %s' % bench
def run(self): bench = Benchmark() # The following will assume all of the images have the same size self.verify_images() # Copy project so we can trash it self.opt_project = self.project.copy() self.prepare_pto(self.opt_project) print 'Building image coordinate map' i_fns = [] for il in self.opt_project.image_lines: i_fns.append(il.get_name()) self.icm = ImageCoordinateMap.from_file_names(i_fns) print 'Built image coordinate map' if self.icm.width() <= self.tw: raise Exception('Decrease tile width') if self.icm.height() <= self.th: raise Exception('Decrease tile height') order = 2 ''' Phase 1: baseline Fully optimize a region in the center of our pano ''' print 'Phase 1: baseline' x0 = (self.icm.width() - self.tw) / 2 if x0 % order != 0: x0 += 1 x1 = x0 + self.tw - 1 y0 = (self.icm.height() - self.th) / 2 if y0 % order != 0: y0 += 1 y1 = y0 + self.th - 1 (center_pto, center_cplis) = self.partial_optimize(x0, x1, y0, y1) merge_pto(center_pto, self.opt_project, center_cplis) ''' Phase 2: predict Now use base center project to predict optimization positions for rest of project Assume that scanning left/right and that backlash will cause rows to alternate ("order 2") Note this will also fill in position estimates for unmatched images x = c0 * c + c1 * r + c2 y = c3 * c + c4 * r + c5 XXX: is there reason to have order 2 y coordinates? ''' print 'Phase 2: predict' ((c0s, c1s, c2s), (c3s, c4s, c5s)) = linearize(self.opt_project, center_pto, allow_missing=False, order=order) # Exclude filenames directly optimized center_is = set() for il in center_pto.get_image_lines(): center_is.add(self.opt_project.i2i(center_pto, il.get_index())) for row in xrange(self.icm.width()): for col in xrange(self.icm.height()): fn = self.icm.get_image(col, row) il = self.project.img_fn2l(fn) # Skip directly optimized lines if il.get_index() in center_is: continue # Otherwise predict position x = c0s[col%order] * col + c1s[col%order] * row + c2s[col%order] il.set_variable('d', x) y = c3s[row%order] * col + c4s[row%order] * row + c5s[row%order] il.set_variable('e', y) ''' Phase 3: optimize Moving out from center, optimize sub-sections based off of prediction Move in a cross pattern Left Right Up Down Expand scope ''' ''' x0 = self.icm.width() / 2 if x0 % order != 0: x0 += 1 x1 = x0 + self.tw - 1 y0 = self.icm.height() / 2 if y0 % order != 0: y0 += 1 y1 = y0 + self.th - 1 (center_pto, center_cplis) = self.partial_optimize(x0, x1, y0, y1) merge_pto(center_pto, self.opt_project, center_cplis) ''' if self.debug: print self.project bench.stop() print 'Optimized project in %s' % bench