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 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 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 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 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 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
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 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 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 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 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): 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 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