def color_pdf(latex_file, bg_color, fg_color): use_preview_pdf_re = re.compile("(\s*\\\\usepackage\[[^]]+)((pdftex|xetex)\]{preview})") tmp = mkstemp() fg = "" if fg_color != "0.000000,0.000000,0.000000": fg = ' \\AtBeginDocument{\\let\\oldpreview\\preview\\renewcommand\\preview{\\oldpreview\\color[rgb]{%s}}}\n' % (fg_color) success = 0 try: for line in open(latex_file, 'r').readlines(): match = use_preview_pdf_re.match(line) if match == None: tmp.write(line) continue success = 1 tmp.write(" \\usepackage{color}\n" \ " \\pagecolor[rgb]{%s}\n" \ "%s" \ "%s\n" \ % (bg_color, fg, match.group())) continue except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in color_pdf! Unable to open "%s"' % latex_file) warning(`sys.exc_type` + ',' + `sys.exc_value`) if success: copyfileobj(tmp, open(latex_file,"wb"), 1) return success
def legacy_extract_metrics_info(log_file): log_re = re.compile("Preview: ([ST])") data_re = re.compile("(-?[0-9]+) (-?[0-9]+) (-?[0-9]+) (-?[0-9]+)") tp_ascent = 0.0 tp_descent = 0.0 success = 0 results = [] try: for line in open(log_file, 'r').readlines(): match = log_re.match(line) if match == None: continue snippet = (match.group(1) == 'S') success = 1 match = data_re.search(line) if match == None: error("Unexpected data in %s\n%s" % (log_file, line)) if snippet: ascent = string.atof(match.group(2)) descent = string.atof(match.group(3)) frac = 0.5 if ascent == 0 and descent == 0: # This is an empty image, forbid its display frac = -1.0 elif ascent >= 0 or descent >= 0: ascent = ascent + tp_ascent descent = descent - tp_descent if abs(ascent + descent) > 0.1: frac = ascent / (ascent + descent) # Sanity check if frac < 0 or frac > 1: frac = 0.5 results.append((int(match.group(1)), frac)) else: tp_descent = string.atof(match.group(2)) tp_ascent = string.atof(match.group(4)) except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in legacy_extract_metrics_info! Unable to open "%s"' % log_file) warning(`sys.exc_type` + ',' + `sys.exc_value`) if success == 0: error("Failed to extract metrics info from %s" % log_file) return results
def extract_metrics_info(log_file, metrics_file): metrics = open(metrics_file, 'w') log_re = re.compile("Preview: ([ST])") data_re = re.compile("(-?[0-9]+) (-?[0-9]+) (-?[0-9]+) (-?[0-9]+)") tp_ascent = 0.0 tp_descent = 0.0 success = 0 try: for line in open(log_file, 'r').readlines(): match = log_re.match(line) if match == None: continue snippet = (match.group(1) == 'S') success = 1 match = data_re.search(line) if match == None: error("Unexpected data in %s\n%s" % (log_file, line)) if snippet: ascent = string.atoi(match.group(2)) descent = string.atoi(match.group(3)) frac = 0.5 if ascent >= 0 and descent >= 0: ascent = float(ascent) + tp_ascent descent = float(descent) - tp_descent if abs(ascent + descent) > 0.1: frac = ascent / (ascent + descent) # Sanity check if frac < 0 or frac > 1: frac = 0.5 metrics.write("Snippet %s %f\n" % (match.group(1), frac)) else: tp_descent = string.atof(match.group(2)) tp_ascent = string.atof(match.group(4)) except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in extract_metrics_info! Unable to open "%s"' % log_file) warning(`sys.exc_type` + ',' + `sys.exc_value`) return success
def legacy_latex_file(latex_file, fg_color, bg_color): use_preview_re = re.compile(r"\s*\\usepackage\[([^]]+)\]{preview}") fg_color_gr = make_texcolor(fg_color, True) bg_color_gr = make_texcolor(bg_color, True) tmp = mkstemp() success = 0 try: f = open(latex_file, 'r') except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in legacy_latex_file! Unable to open "%s"' % latex_file) warning(`sys.exc_type` + ',' + `sys.exc_value`) for line in f.readlines(): if success: tmp.write(line) continue match = use_preview_re.match(line) if match == None: tmp.write(line) continue success = 1 # Package order: color should be loaded before preview # Preview options: add the options lyx and tightpage tmp.write(r""" \usepackage{color} \definecolor{fg}{rgb}{%s} \definecolor{bg}{rgb}{%s} \pagecolor{bg} \usepackage[%s,tightpage]{preview} \makeatletter \def\t@a{cmr} \if\f@family\t@a \IfFileExists{lmodern.sty}{\usepackage{lmodern}}{\usepackage{ae,aecompl}} \fi \g@addto@macro\preview{\begingroup\color{bg}\special{ps::clippath fill}\color{fg}} \g@addto@macro\endpreview{\endgroup} \makeatother """ % (fg_color_gr, bg_color_gr, match.group(1))) if success: copyfileobj(tmp, open(latex_file,"wb"), 1) return success
def legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output = False, skipMetrics = False): # Move color information, lyx and tightpage options into the latex file. if not legacy_latex_file(latex_file, fg_color, bg_color): error("""Unable to move the color information, and the lyx and tightpage options of preview-latex, into the latex file""") # Compile the latex file. latex_status, latex_stdout = run_latex(latex, latex_file) if latex_status: warning("trying to recover from failed compilation") if pdf_output: return legacy_conversion_step3(latex_file, dpi, output_format, True, skipMetrics) else: return legacy_conversion_step2(latex_file, dpi, output_format, skipMetrics)
def extract_resolution(log_file, dpi): fontsize_re = re.compile("Preview: Fontsize") magnification_re = re.compile("Preview: Magnification") extract_decimal_re = re.compile("([0-9\.]+)") extract_integer_re = re.compile("([0-9]+)") found_fontsize = 0 found_magnification = 0 # Default values magnification = 1000.0 fontsize = 10.0 try: for line in open(log_file, 'r').readlines(): if found_fontsize and found_magnification: break if not found_fontsize: match = fontsize_re.match(line) if match != None: match = extract_decimal_re.search(line) if match == None: error("Unable to parse: %s" % line) fontsize = string.atof(match.group(1)) found_fontsize = 1 continue if not found_magnification: match = magnification_re.match(line) if match != None: match = extract_integer_re.search(line) if match == None: error("Unable to parse: %s" % line) magnification = string.atof(match.group(1)) found_magnification = 1 continue except: warning('Warning in extract_resolution! Unable to open "%s"' % log_file) warning(`sys.exc_type` + ',' + `sys.exc_value`) # This is safe because both fontsize and magnification have # non-zero default values. return dpi * (10.0 / fontsize) * (1000.0 / magnification)
def legacy_conversion_step2(latex_file, dpi, output_format, skipMetrics = False): # External programs used by the script. dvips = find_exe_or_terminate(["dvips"]) # Run the dvi file through dvips. dvi_file = latex_file_re.sub(".dvi", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) dvips_call = '%s -i -o "%s" "%s"' % (dvips, ps_file, dvi_file) dvips_failed = False dvips_status, dvips_stdout = run_command(dvips_call) if dvips_status: warning('Failed: %s %s ... looking for PDF' \ % (os.path.basename(dvips), dvi_file)) dvips_failed = True return legacy_conversion_step3(latex_file, dpi, output_format, dvips_failed, skipMetrics)
def legacy_conversion_step2(latex_file, dpi, output_format, skipMetrics=False): # External programs used by the script. dvips = find_exe_or_terminate(["dvips"]) # Run the dvi file through dvips. dvi_file = latex_file_re.sub(".dvi", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) dvips_call = '%s -i -o "%s" "%s"' % (dvips, ps_file, dvi_file) dvips_failed = False dvips_status, dvips_stdout = run_command(dvips_call) if dvips_status: warning('Failed: %s %s ... looking for PDF' \ % (os.path.basename(dvips), dvi_file)) dvips_failed = True return legacy_conversion_step3(latex_file, dpi, output_format, dvips_failed, skipMetrics)
def legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, gs, gs_device, gs_ext, alpha, resolution, output_format): # Search for pdflatex executable pdflatex = find_exe(["pdflatex"], path) if pdflatex == None: warning("Can't find pdflatex. Some pages failed with all the possible routes.") else: # Create a new LaTeX file from the original but only with failed pages pdf_latex_file = latex_file_re.sub("_pdflatex.tex", latex_file) filter_pages(latex_file, pdf_latex_file, failed_pages) # pdflatex call pdflatex_call = '%s "%s"' % (pdflatex, pdf_latex_file) pdflatex_status, pdflatex_stdout = run_command(pdflatex_call) pdf_file = latex_file_re.sub(".pdf", pdf_latex_file) # GhostScript call to produce bitmaps gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_re.sub("", pdf_latex_file), \ gs_ext, alpha, alpha, resolution, pdf_file) gs_status, gs_stdout = run_command(gs_call) if gs_status != None: # Give up! warning("Some pages failed with all the possible routes") else: # We've done it! pdf_log_file = latex_file_re.sub(".log", pdf_latex_file) pdf_metrics = legacy_extract_metrics_info(pdf_log_file) original_bitmap = latex_file_re.sub("%d." + output_format, pdf_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join the metrics with the those from dvips and rename the bitmap images join_metrics_and_rename(legacy_metrics, pdf_metrics, failed_pages, original_bitmap, destination_bitmap)
def legacy_latex_file(latex_file, fg_color, bg_color, bg_color_gr): use_preview_dvi_re = re.compile("(\s*\\\\usepackage\[[^]]+)(dvips\]{preview})") use_preview_pdf_re = re.compile("(\s*\\\\usepackage\[[^]]+)(pdftex\]{preview})") tmp = mkstemp() success = 0 try: for line in open(latex_file, 'r').readlines(): match = use_preview_dvi_re.match(line) if match == None: match = use_preview_pdf_re.match(line) if match == None: tmp.write(line) continue success = 1 tmp.write(" \\usepackage{color}\n" \ " \\pagecolor[rgb]{%s}\n" \ "%s\n" \ % (bg_color_gr, match.group())) continue success = 1 tmp.write("%stightpage,%s\n" \ " \\AtBeginDocument{\\AtBeginDvi{%%\n" \ " \\special{!userdict begin/bop-hook{//bop-hook exec\n" \ " <%s%s>{255 div}forall setrgbcolor\n" \ " clippath fill setrgbcolor}bind def end}}}\n" \ % (match.group(1), match.group(2), fg_color, bg_color)) except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in legacy_latex_file! Unable to open "%s"' % latex_file) warning(`sys.exc_type` + ',' + `sys.exc_value`) if success: copyfileobj(tmp, open(latex_file,"wb"), 1) return success
def legacy_conversion(argv, skipMetrics = False): latex_commands = ["latex", "pplatex", "platex", "latex2e"] # Parse and manipulate the command line arguments. if len(argv) == 7: latex_commands = [argv[6]] elif len(argv) != 6: error(usage(argv[0])) dir, latex_file = os.path.split(argv[1]) if len(dir) != 0: os.chdir(dir) dpi = string.atoi(argv[2]) output_format = argv[3] fg_color = argv[4] bg_color = argv[5] bg_color_gr = make_texcolor(argv[5], True) # External programs used by the script. latex = find_exe_or_terminate(latex_commands, path) # Move color information into the latex file. if not legacy_latex_file(latex_file, fg_color, bg_color, bg_color_gr): error("Unable to move color info into the latex file") # Compile the latex file. latex_call = '%s "%s"' % (latex, latex_file) latex_status, latex_stdout = run_command(latex_call) if latex_status != None: warning("%s had problems compiling %s" \ % (os.path.basename(latex), latex_file)) return legacy_conversion_step2(latex_file, dpi, output_format, skipMetrics)
return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe(["pngtopnm"]) if pngtopnm == None: progress("Using the legacy conversion method (pngtopnm not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Compile the latex file. error_pages = [] latex_status, latex_stdout = run_latex(latex, latex_file, bibtex) if latex_status: warning("trying to recover from failed compilation") error_pages = check_latex_log(latex_file_re.sub(".log", latex_file)) # The dvi output file name dvi_file = latex_file_re.sub(".dvi", latex_file) # If there's no DVI output, look for PDF and go to legacy or fail if not os.path.isfile(dvi_file): # No DVI, is there a PDF? pdf_file = latex_file_re.sub(".pdf", latex_file) if os.path.isfile(pdf_file): progress("%s produced a PDF output, fallback to legacy." \ % (os.path.basename(latex))) progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, True)
def main(argv): # Parse and manipulate the command line arguments. if len(argv) != 6 and len(argv) != 7: error(usage(argv[0])) output_format = string.lower(argv[1]) dir, latex_file = os.path.split(argv[2]) if len(dir) != 0: os.chdir(dir) dpi = string.atoi(argv[3]) fg_color = make_texcolor(argv[4], False) bg_color = make_texcolor(argv[5], False) bg_color_gr = make_texcolor(argv[5], True) # External programs used by the script. path = string.split(os.environ["PATH"], os.pathsep) if len(argv) == 7: latex = argv[6] else: latex = find_exe_or_terminate(["latex", "pplatex", "platex", "latex2e"], path) # This can go once dvipng becomes widespread. dvipng = find_exe(["dvipng"], path) if dvipng == None: # The data is input to legacy_conversion in as similar # as possible a manner to that input to the code used in # LyX 1.3.x. vec = [ argv[0], argv[2], argv[3], argv[1], argv[4], argv[5], latex ] return legacy_conversion(vec) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe_or_terminate(["pngtopnm"], path) # Move color information for PDF into the latex file. if not color_pdf(latex_file, bg_color_gr): error("Unable to move color info into the latex file") # Compile the latex file. latex_call = '%s "%s"' % (latex, latex_file) latex_status, latex_stdout = run_command(latex_call) if latex_status != None: warning("%s failed to compile %s" \ % (os.path.basename(latex), latex_file)) if latex == "xelatex": warning("Using XeTeX") # FIXME: skip unnecessary dvips trial in legacy_conversion_step2 return legacy_conversion_step2(latex_file, dpi, output_format) # Run the dvi file through dvipng. dvi_file = latex_file_re.sub(".dvi", latex_file) dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" "%s"' \ % (dvipng, dpi, fg_color, bg_color, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status != None: warning("%s failed to generate images from %s ... looking for PDF" \ % (os.path.basename(dvipng), dvi_file)) # FIXME: skip unnecessary dvips trial in legacy_conversion_step2 return legacy_conversion_step2(latex_file, dpi, output_format) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) if not extract_metrics_info(dvipng_stdout, metrics_file): error("Failed to extract metrics info from dvipng") # Convert images to ppm format if necessary. if output_format == "ppm": convert_to_ppm_format(pngtopnm, latex_file_re.sub("", latex_file)) return 0
def main(argv): # Parse and manipulate the command line arguments. if len(argv) != 6 and len(argv) != 7: error(usage(argv[0])) output_format = string.lower(argv[1]) dir, latex_file = os.path.split(argv[2]) if len(dir) != 0: os.chdir(dir) dpi = string.atoi(argv[3]) fg_color = make_texcolor(argv[4], False) bg_color = make_texcolor(argv[5], False) fg_color_gr = make_texcolor(argv[4], True) bg_color_gr = make_texcolor(argv[5], True) # External programs used by the script. if len(argv) == 7: latex = argv[6] else: latex = find_exe_or_terminate(["latex", "pplatex", "platex", "latex2e"], path) # Omit font size specification in latex file. fix_latex_file(latex_file) # This can go once dvipng becomes widespread. dvipng = find_exe(["dvipng"], path) if dvipng == None: # The data is input to legacy_conversion in as similar # as possible a manner to that input to the code used in # LyX 1.3.x. vec = [ argv[0], argv[2], argv[3], argv[1], argv[4], argv[5], latex ] return legacy_conversion(vec) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe_or_terminate(["pngtopnm"], path) # Move color information for PDF into the latex file. if not color_pdf(latex_file, bg_color_gr, fg_color_gr): error("Unable to move color info into the latex file") # Compile the latex file. latex_call = '%s "%s"' % (latex, latex_file) latex_status, latex_stdout = run_command(latex_call) if latex_status != None: warning("%s had problems compiling %s" \ % (os.path.basename(latex), latex_file)) if latex == "xelatex": warning("Using XeTeX") # FIXME: skip unnecessary dvips trial in legacy_conversion_step2 return legacy_conversion_step2(latex_file, dpi, output_format) # The dvi output file name dvi_file = latex_file_re.sub(".dvi", latex_file) # If there's no DVI output, look for PDF and go to legacy or fail if not os.path.isfile(dvi_file): # No DVI, is there a PDF? pdf_file = latex_file_re.sub(".pdf", latex_file) if os.path.isfile(pdf_file): warning("%s produced a PDF output, fallback to legacy." % \ (os.path.basename(latex))) return legacy_conversion_step2(latex_file, dpi, output_format) else: error("No DVI or PDF output. %s failed." \ % (os.path.basename(latex))) # Look for PS literals in DVI pages # ps_pages: list of page indexes of pages containing PS literals # page_count: total number of pages # pages_parameter: parameter for dvipng to exclude pages with PostScript (ps_pages, page_count, pages_parameter) = find_ps_pages(dvi_file) # If all pages need PostScript, directly use the legacy method. if len(ps_pages) == page_count: vec = [argv[0], argv[2], argv[3], argv[1], argv[4], argv[5], latex] return legacy_conversion(vec) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, dpi, fg_color, bg_color, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status != None: warning("%s failed to generate images from %s... fallback to legacy method" \ % (os.path.basename(dvipng), dvi_file)) # FIXME: skip unnecessary dvips trial in legacy_conversion_step2 return legacy_conversion_step2(latex_file, dpi, output_format) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) # If some pages require PostScript pass them to legacy method if len(ps_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, ps_pages) # Pass the new LaTeX file to the legacy method vec = [ argv[0], latex_file_re.sub("_legacy.tex", argv[2]), \ argv[3], argv[1], argv[4], argv[5], latex ] legacy_metrics = legacy_conversion(vec, True)[1] # Now we need to mix metrics data from dvipng and the legacy method original_bitmap = latex_file_re.sub("%d." + output_format, legacy_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join metrics from dvipng and legacy, and rename legacy bitmaps join_metrics_and_rename(dvipng_metrics, legacy_metrics, ps_pages, original_bitmap, destination_bitmap) # Convert images to ppm format if necessary. if output_format == "ppm": convert_to_ppm_format(pngtopnm, latex_file_re.sub("", latex_file)) # Actually create the .metrics file write_metrics_info(dvipng_metrics, metrics_file) return (0, dvipng_metrics)
bg_color, latex, pdf_output) elif len(pdf_pages) == page_count: progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, "pdflatex", True) # Retrieve resolution resolution = extract_resolution(latex_log, dpi) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, resolution, fg_color_dvipng, bg_color_dvipng, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status: warning("%s failed to generate images from %s... fallback to legacy method" \ % (os.path.basename(dvipng), dvi_file)) progress("Using the legacy conversion method (dvipng failed)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) # If some pages require PostScript pass them to legacy method if len(ps_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, ps_pages)
def legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, use_pdftocairo, conv, gs_device, gs_ext, alpha, resolution, output_format): # Search for pdflatex executable pdflatex = find_exe(["pdflatex"]) if pdflatex == None: warning("Can't find pdflatex. Some pages failed with all the possible routes.") else: # Create a new LaTeX file from the original but only with failed pages pdf_latex_file = latex_file_re.sub("_pdflatex.tex", latex_file) filter_pages(latex_file, pdf_latex_file, failed_pages) # pdflatex call error_pages = [] pdflatex_status, pdflatex_stdout = run_latex(pdflatex, pdf_latex_file) if pdflatex_status: error_pages = check_latex_log(latex_file_re.sub(".log", pdf_latex_file)) pdf_file = latex_file_re.sub(".pdf", pdf_latex_file) latex_file_root = latex_file_re.sub("", pdf_latex_file) # Converter call to produce bitmaps if use_pdftocairo: conv_call = '%s -png -transp -r %d "%s" "%s"' \ % (conv, resolution, pdf_file, latex_file_root) conv_status, conv_stdout = run_command(conv_call) if not conv_status: seqnum_re = re.compile("-([0-9]+)") for name in glob.glob("%s-*.png" % latex_file_root): match = seqnum_re.search(name) if match != None: new_name = seqnum_re.sub(str(int(match.group(1))), name) os.rename(name, new_name) else: conv_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (conv, gs_device, latex_file_root, \ gs_ext, alpha, alpha, resolution, pdf_file) conv_status, conv_stdout = run_command(conv_call) if conv_status: # Give up! warning("Some pages failed with all the possible routes") else: # We've done it! pdf_log_file = latex_file_re.sub(".log", pdf_latex_file) pdf_metrics = legacy_extract_metrics_info(pdf_log_file) # Invalidate metrics for pages that produced errors if len(error_pages) > 0: for index in error_pages: pdf_metrics.pop(index - 1) pdf_metrics.insert(index - 1, (index, -1.0)) original_bitmap = latex_file_re.sub("%d." + output_format, pdf_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join the metrics with the those from dvips and rename the bitmap images join_metrics_and_rename(legacy_metrics, pdf_metrics, failed_pages, original_bitmap, destination_bitmap)
def legacy_conversion_step3(latex_file, dpi, output_format, dvips_failed, skipMetrics = False): # External programs used by the script. gs = find_exe_or_terminate(["gswin32c", "gswin64c", "gs"]) pnmcrop = find_exe(["pnmcrop"]) pdftocairo = find_exe(["pdftocairo"]) epstopdf = find_exe(["epstopdf"]) use_pdftocairo = pdftocairo != None and output_format == "png" if use_pdftocairo: conv = pdftocairo else: conv = gs # Files to process pdf_file = latex_file_re.sub(".pdf", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) # The latex file name without extension latex_file_root = latex_file_re.sub("", latex_file) # Extract resolution data for the converter from the log file. log_file = latex_file_re.sub(".log", latex_file) resolution = extract_resolution(log_file, dpi) # Check whether some pages produced errors error_pages = check_latex_log(log_file) # Older versions of gs have problems with a large degree of # anti-aliasing at high resolutions alpha = 4 if resolution > 150: alpha = 2 gs_device = "png16m" gs_ext = "png" if output_format == "ppm": gs_device = "pnmraw" gs_ext = "ppm" # Extract the metrics from the log file legacy_metrics = legacy_extract_metrics_info(log_file) # List of pages which failed to produce a correct output failed_pages = [] # Generate the bitmap images if dvips_failed: # dvips failed, maybe there's a PDF, try to produce bitmaps if use_pdftocairo: conv_call = '%s -png -transp -r %d "%s" "%s"' \ % (pdftocairo, resolution, pdf_file, latex_file_root) conv_status, conv_stdout = run_command(conv_call) if not conv_status: seqnum_re = re.compile("-([0-9]+)") for name in glob.glob("%s-*.png" % latex_file_root): match = seqnum_re.search(name) if match != None: new_name = seqnum_re.sub(str(int(match.group(1))), name) os.rename(name, new_name) else: conv_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_root, \ gs_ext, alpha, alpha, resolution, pdf_file) conv_status, conv_stdout = run_command(conv_call) if conv_status: error("Failed: %s %s" % (os.path.basename(conv), pdf_file)) else: # Model for calling the converter on each file if use_pdftocairo and epstopdf != None: conv_call = '%s -png -transp -singlefile -r %d "%%s" "%s%%d"' \ % (pdftocairo, resolution, latex_file_root) else: conv_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%%s"' \ % (gs, gs_device, latex_file_root, \ gs_ext, alpha, alpha, resolution) i = 0 # Collect all the PostScript files (like *.001, *.002, ...) ps_files = glob.glob("%s.[0-9][0-9][0-9]" % latex_file_root) ps_files.sort() # Call the converter for each file for file in ps_files: i = i + 1 progress("Processing page %s, file %s" % (i, file)) if use_pdftocairo and epstopdf != None: conv_name = "epstopdf" conv_status, conv_stdout = run_command("%s --outfile=%s.pdf %s" % (epstopdf, file, file)) if not conv_status: conv_name = "pdftocairo" file = file + ".pdf" conv_status, conv_stdout = run_command(conv_call % (file, i)) else: conv_name = "ghostscript" conv_status, conv_stdout = run_command(conv_call % (i, file)) if conv_status: # The converter failed, keep track of this warning("%s failed on page %s, file %s" % (conv_name, i, file)) failed_pages.append(i) # Pass failed pages to pdflatex if len(failed_pages) > 0: warning("Now trying to obtain failed previews through pdflatex") legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, use_pdftocairo, conv, gs_device, gs_ext, alpha, resolution, output_format) # Invalidate metrics for pages that produced errors if len(error_pages) > 0: for index in error_pages: if index not in failed_pages: legacy_metrics.pop(index - 1) legacy_metrics.insert(index - 1, (index, -1.0)) # Crop the ppm images if pnmcrop != None and output_format == "ppm": crop_files(pnmcrop, latex_file_root) # Allow to skip .metrics creation for custom management # (see the dvipng method) if not skipMetrics: # Extract metrics info from the log file. metrics_file = latex_file_re.sub(".metrics", latex_file) write_metrics_info(legacy_metrics, metrics_file) return (0, legacy_metrics)
def legacy_latex_file(latex_file, fg_color, bg_color): use_polyglossia_re = re.compile(b"\\s*\\\\usepackage{polyglossia}") use_preview_re = re.compile(b"\\s*\\\\usepackage\\[([^]]+)\\]{preview}") fg_color_gr = make_texcolor(fg_color, True) bg_color_gr = make_texcolor(bg_color, True) tmp = tempfile.TemporaryFile() success = 0 try: f = open(latex_file, 'rb') except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in legacy_latex_file! Unable to open "%s"' % latex_file) warning(repr(sys.exc_info()[0]) + ',' + repr(sys.exc_info()[1])) polyglossia = False for line in f.readlines(): if success: tmp.write(line) continue match = use_preview_re.match(line) polymatch = use_polyglossia_re.match(line) # Package order: # * if polyglossia is used, we need to load color before that # (also, we do not have to load lmodern) # * else, color should be loaded before preview if match == None: if polymatch == None: tmp.write(line) continue else: tmp.write(b""" \\usepackage{color} \\definecolor{fg}{rgb}{%s} \\definecolor{bg}{rgb}{%s} \\pagecolor{bg} \\usepackage{polyglossia} """ % (fg_color_gr, bg_color_gr)) polyglossia = True continue success = 1 # Preview options: add the options lyx and tightpage previewopts = match.group(1) if not polyglossia: tmp.write(b""" \\usepackage{color} \\definecolor{fg}{rgb}{%s} \\definecolor{bg}{rgb}{%s} \\pagecolor{bg} \\usepackage[%s,tightpage]{preview} \\makeatletter \\def\\t@a{cmr} \\if\\f@family\\t@a \\IfFileExists{lmodern.sty}{\\usepackage{lmodern}}{\\usepackage{ae,aecompl}} \\fi \\g@addto@macro\\preview{\\begingroup\\color{bg}\\special{ps::clippath fill}\\color{fg}} \\g@addto@macro\\endpreview{\\endgroup} \\makeatother """ % (fg_color_gr, bg_color_gr, previewopts)) else: tmp.write(b""" \\usepackage[%s,tightpage]{preview} \\makeatletter \\g@addto@macro\\preview{\\begingroup\\color{bg}\\special{ps::clippath fill}\\color{fg}} \\g@addto@macro\\endpreview{\\endgroup} \\makeatother """ % previewopts) if success: copyfileobj(tmp, open(latex_file,"wb"), 1) return success
def legacy_latex_file(latex_file, fg_color, bg_color): use_polyglossia_re = re.compile(b"\\s*\\\\usepackage{polyglossia}") use_preview_re = re.compile(b"\\s*\\\\usepackage\\[([^]]+)\\]{preview}") fg_color_gr = make_texcolor(fg_color, True) bg_color_gr = make_texcolor(bg_color, True) tmp = tempfile.TemporaryFile() success = 0 try: f = open(latex_file, 'rb') except: # Unable to open the file, but do nothing here because # the calling function will act on the value of 'success'. warning('Warning in legacy_latex_file! Unable to open "%s"' % latex_file) warning(repr(sys.exc_info()[0]) + ',' + repr(sys.exc_info()[1])) polyglossia = False for line in f.readlines(): if success: tmp.write(line) continue match = use_preview_re.match(line) polymatch = use_polyglossia_re.match(line) # Package order: # * if polyglossia is used, we need to load color before that # (also, we do not have to load lmodern) # * else, color should be loaded before preview if match == None: if polymatch == None: tmp.write(line) continue else: tmp.write(b""" \\usepackage{color} \\definecolor{fg}{rgb}{%s} \\definecolor{bg}{rgb}{%s} \\pagecolor{bg} \\usepackage{polyglossia} """ % (fg_color_gr, bg_color_gr)) polyglossia = True continue success = 1 # Preview options: add the options lyx and tightpage previewopts = match.group(1) if not polyglossia: tmp.write(b""" \\usepackage{color} \\definecolor{fg}{rgb}{%s} \\definecolor{bg}{rgb}{%s} \\pagecolor{bg} \\usepackage[%s,tightpage]{preview} \\makeatletter \\def\\t@a{cmr} \\if\\f@family\\t@a \\IfFileExists{lmodern.sty}{\\usepackage{lmodern}}{\\usepackage{ae,aecompl}} \\fi \\g@addto@macro\\preview{\\begingroup\\color{bg}\\special{ps::clippath fill}\\color{fg}} \\g@addto@macro\\endpreview{\\endgroup} \\makeatother """ % (fg_color_gr, bg_color_gr, previewopts)) else: tmp.write(b""" \\usepackage[%s,tightpage]{preview} \\makeatletter \\g@addto@macro\\preview{\\begingroup\\color{bg}\\special{ps::clippath fill}\\color{fg}} \\g@addto@macro\\endpreview{\\endgroup} \\makeatother """ % previewopts) if success: copyfileobj(tmp, open(latex_file, "wb"), 1) return success
# pages_parameter: parameter for dvipng to exclude pages with PostScript (ps_pages, page_count, pages_parameter) = find_ps_pages(dvi_file) # If all pages need PostScript, directly use the legacy method. if len(ps_pages) == page_count: progress("Using the legacy conversion method (PostScript support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, dpi, fg_color_dvipng, bg_color_dvipng, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status: warning("%s failed to generate images from %s... fallback to legacy method" \ % (os.path.basename(dvipng), dvi_file)) progress("Using the legacy conversion method (dvipng failed)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) # If some pages require PostScript pass them to legacy method if len(ps_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, ps_pages)
def main(argv): # Set defaults. dpi = 128 fg_color = "000000" bg_color = "ffffff" bibtex = None latex = None lilypond = False lilypond_book = None output_format = "png" script_name = argv[0] # Parse and manipulate the command line arguments. try: (opts, args) = getopt.gnu_getopt(argv[1:], "dhv", ["bibtex=", "bg=", "debug", "dpi=", "fg=", "help", "latex=", "lilypond", "lilypond-book=", "png", "ppm", "verbose"]) except getopt.GetoptError as err: error("%s\n%s" % (err, usage(script_name))) opts.reverse() for opt, val in opts: if opt in ("-h", "--help"): print(usage(script_name)) sys.exit(0) elif opt == "--bibtex": bibtex = [val] elif opt == "--bg": bg_color = val elif opt in ("-d", "--debug"): import lyxpreview_tools lyxpreview_tools.debug = True elif opt == "--dpi": try: dpi = int(val) except: error("Cannot convert %s to an integer value" % val) elif opt == "--fg": fg_color = val elif opt == "--latex": latex = [val] elif opt == "--lilypond": lilypond = True elif opt == "--lilypond-book": lilypond_book = [val] elif opt in ("--png", "--ppm"): output_format = opt[2:] elif opt in ("-v", "--verbose"): import lyxpreview_tools lyxpreview_tools.verbose = True # Determine input file if len(args) != 1: err = "A single input file is required, %s given" % (len(args) or "none") error("%s\n%s" % (err, usage(script_name))) input_path = args[0] dir, latex_file = os.path.split(input_path) # Check for the input file if not os.path.exists(input_path): error('File "%s" not found.' % input_path) if len(dir) != 0: os.chdir(dir) if lyxpreview_tools.verbose: f_out = open('debug.txt', 'a') sys.stdout = f_out sys.stderr = f_out # Echo the settings progress("Running Python %s" % str(sys.version_info[:3])) progress("Starting %s..." % script_name) if os.name == "nt": progress("Use win32_modules: %d" % lyxpreview_tools.use_win32_modules) progress("Output format: %s" % output_format) progress("Foreground color: %s" % fg_color) progress("Background color: %s" % bg_color) progress("Resolution (dpi): %s" % dpi) progress("File to process: %s" % input_path) # For python > 2 convert strings to bytes if not PY2: fg_color = bytes(fg_color, 'ascii') bg_color = bytes(bg_color, 'ascii') fg_color_dvipng = make_texcolor(fg_color, False) bg_color_dvipng = make_texcolor(bg_color, False) # For python > 2 convert bytes to string if not PY2: fg_color_dvipng = fg_color_dvipng.decode('ascii') bg_color_dvipng = bg_color_dvipng.decode('ascii') # External programs used by the script. latex = find_exe_or_terminate(latex or latex_commands) bibtex = find_exe(bibtex or bibtex_commands) if lilypond: lilypond_book = find_exe_or_terminate(lilypond_book or ["lilypond-book --safe"]) # These flavors of latex are known to produce pdf output pdf_output = latex in pdflatex_commands progress("Latex command: %s" % latex) progress("Latex produces pdf output: %s" % pdf_output) progress("Bibtex command: %s" % bibtex) progress("Lilypond-book command: %s" % lilypond_book) progress("Preprocess through lilypond-book: %s" % lilypond) progress("Altering the latex file for font size and colors") # Make sure that multiple defined macros and the microtype package # don't cause issues in the latex file. fix_latex_file(latex_file, pdf_output) if lilypond: progress("Preprocess the latex file through %s" % lilypond_book) if pdf_output: lilypond_book += " --pdf" lilypond_book += " --latex-program=%s" % latex.split()[0] # Make a copy of the latex file lytex_file = latex_file_re.sub(".lytex", latex_file) shutil.copyfile(latex_file, lytex_file) # Preprocess the latex file through lilypond-book. lytex_status, lytex_stdout = run_tex(lilypond_book, lytex_file) if pdf_output: progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # This can go once dvipng becomes widespread. dvipng = find_exe(["dvipng"]) if dvipng == None: progress("Using the legacy conversion method (dvipng not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) dv2dt = find_exe(["dv2dt"]) if dv2dt == None: progress("Using the legacy conversion method (dv2dt not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe(["pngtopnm"]) if pngtopnm == None: progress("Using the legacy conversion method (pngtopnm not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Compile the latex file. error_pages = [] latex_status, latex_stdout = run_latex(latex, latex_file, bibtex) latex_log = latex_file_re.sub(".log", latex_file) if latex_status: progress("Will try to recover from %s failure" % latex) error_pages = check_latex_log(latex_log) # The dvi output file name dvi_file = latex_file_re.sub(".dvi", latex_file) # If there's no DVI output, look for PDF and go to legacy or fail if not os.path.isfile(dvi_file): # No DVI, is there a PDF? pdf_file = latex_file_re.sub(".pdf", latex_file) if os.path.isfile(pdf_file): progress("%s produced a PDF output, fallback to legacy." \ % (os.path.basename(latex))) progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, True) else: error("No DVI or PDF output. %s failed." \ % (os.path.basename(latex))) # Look for PS literals or inclusion of pdflatex files in DVI pages # ps_pages: list of indexes of pages containing PS literals # pdf_pages: list of indexes of pages requiring running pdflatex # page_count: total number of pages # pages_parameter: parameter for dvipng to exclude pages with PostScript (ps_pages, pdf_pages, page_count, pages_parameter) = find_ps_pages(dvi_file) # If all pages need PostScript or pdflatex, directly use the legacy method. if len(ps_pages) == page_count: progress("Using the legacy conversion method (PostScript support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) elif len(pdf_pages) == page_count: progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, "pdflatex", True) # Retrieve resolution resolution = extract_resolution(latex_log, dpi) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, resolution, fg_color_dvipng, bg_color_dvipng, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status: warning("%s failed to generate images from %s... fallback to legacy method" \ % (os.path.basename(dvipng), dvi_file)) progress("Using the legacy conversion method (dvipng failed)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) # If some pages require PostScript pass them to legacy method if len(ps_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, ps_pages) # Pass the new LaTeX file to the legacy method progress("Pages %s include postscript specials" % ps_pages) progress("Using the legacy conversion method (PostScript support)") legacy_status, legacy_metrics = legacy_conversion_step1(legacy_latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output, True) # Now we need to mix metrics data from dvipng and the legacy method original_bitmap = latex_file_re.sub("%d." + output_format, legacy_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join metrics from dvipng and legacy, and rename legacy bitmaps join_metrics_and_rename(dvipng_metrics, legacy_metrics, ps_pages, original_bitmap, destination_bitmap) # If some pages require running pdflatex pass them to legacy method if len(pdf_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, pdf_pages) # Pass the new LaTeX file to the legacy method progress("Pages %s require processing with pdflatex" % pdf_pages) progress("Using the legacy conversion method (PDF support)") legacy_status, legacy_metrics = legacy_conversion_step1(legacy_latex_file, dpi, output_format, fg_color, bg_color, "pdflatex", True, True) # Now we need to mix metrics data from dvipng and the legacy method original_bitmap = latex_file_re.sub("%d." + output_format, legacy_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join metrics from dvipng and legacy, and rename legacy bitmaps join_metrics_and_rename(dvipng_metrics, legacy_metrics, pdf_pages, original_bitmap, destination_bitmap) # Invalidate metrics for pages that produced errors if len(error_pages) > 0: error_count = 0 for index in error_pages: if index not in ps_pages and index not in pdf_pages: dvipng_metrics.pop(index - 1) dvipng_metrics.insert(index - 1, (index, -1.0)) error_count += 1 if error_count: warning("Failed to produce %d preview snippet(s)" % error_count) # Convert images to ppm format if necessary. if output_format == "ppm": convert_to_ppm_format(pngtopnm, latex_file_re.sub("", latex_file)) # Actually create the .metrics file write_metrics_info(dvipng_metrics, metrics_file) return (0, dvipng_metrics)
def main(argv): # Parse and manipulate the command line arguments. if len(argv) != 6 and len(argv) != 7: error(usage(argv[0])) output_format = string.lower(argv[1]) dir, latex_file = os.path.split(argv[2]) if len(dir) != 0: os.chdir(dir) dpi = string.atoi(argv[3]) fg_color = make_texcolor(argv[4], False) bg_color = make_texcolor(argv[5], False) fg_color_gr = make_texcolor(argv[4], True) bg_color_gr = make_texcolor(argv[5], True) # External programs used by the script. path = string.split(os.environ["PATH"], os.pathsep) if len(argv) == 7: latex = argv[6] else: latex = find_exe_or_terminate(["latex", "pplatex", "platex", "latex2e"], path) lilypond_book = find_exe_or_terminate(["lilypond-book"], path) # Omit font size specification in latex file. fix_latex_file(latex_file) # Make a copy of the latex file lytex_file = latex_file_re.sub(".lytex", latex_file) shutil.copyfile(latex_file, lytex_file) # Determine whether we need pdf or eps output pdf_output = latex in ["lualatex", "pdflatex", "xelatex"] # Preprocess the latex file through lilypond-book. if pdf_output: lytex_call = '%s --safe --pdf --latex-program=%s "%s"' % (lilypond_book, latex, lytex_file) else: lytex_call = '%s --safe --latex-program=%s "%s"' % (lilypond_book, latex, lytex_file) lytex_status, lytex_stdout = run_command(lytex_call) if lytex_status != None: warning("%s failed to compile %s" \ % (os.path.basename(lilypond_book), lytex_file)) warning(lytex_stdout) # This can go once dvipng becomes widespread. dvipng = find_exe(["dvipng"], path) if dvipng == None: # The data is input to legacy_conversion in as similar # as possible a manner to that input to the code used in # LyX 1.3.x. vec = [ argv[0], argv[2], argv[3], argv[1], argv[4], argv[5], latex ] return legacy_conversion(vec) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe_or_terminate(["pngtopnm"], path) # Move color information for PDF into the latex file. if not color_pdf(latex_file, bg_color_gr, fg_color_gr): error("Unable to move color info into the latex file") # Compile the latex file. latex_call = '%s "%s"' % (latex, latex_file) latex_status, latex_stdout = run_command(latex_call) if latex_status != None: warning("%s had problems compiling %s" \ % (os.path.basename(latex), latex_file)) warning(latex_stdout) if latex == "xelatex": warning("Using XeTeX") # FIXME: skip unnecessary dvips trial in legacy_conversion_step2 return legacy_conversion_step2(latex_file, dpi, output_format) # The dvi output file name dvi_file = latex_file_re.sub(".dvi", latex_file) # Check for PostScript specials in the dvi, badly supported by dvipng # This is required for correct rendering of PSTricks and TikZ dv2dt = find_exe_or_terminate(["dv2dt"], path) dv2dt_call = '%s "%s"' % (dv2dt, dvi_file) # The output from dv2dt goes to stdout dv2dt_status, dv2dt_output = run_command(dv2dt_call) psliteral_re = re.compile("^special[1-4] [0-9]+ '(\"|ps:)") # Parse the dtl file looking for PostScript specials. # Pages using PostScript specials are recorded in ps_pages and then # used to create a different LaTeX file for processing in legacy mode. page_has_ps = False page_index = 0 ps_pages = [] for line in dv2dt_output.split("\n"): # New page if line.startswith("bop"): page_has_ps = False page_index += 1 # End of page if line.startswith("eop") and page_has_ps: # We save in a list all the PostScript pages ps_pages.append(page_index) if psliteral_re.match(line) != None: # Literal PostScript special detected! page_has_ps = True pages_parameter = "" if len(ps_pages) == page_index: # All pages need PostScript, so directly use the legacy method. vec = [argv[0], argv[2], argv[3], argv[1], argv[4], argv[5], latex] return legacy_conversion(vec) elif len(ps_pages) > 0: # Don't process Postscript pages with dvipng by selecting the # wanted pages through the -pp parameter. E.g., dvipng -pp 4-12,14,64 pages_parameter = " -pp " skip = True last = -1 # Use page ranges, as a list of pages could exceed command line # maximum length (especially under Win32) for index in xrange(1, page_index + 1): if (not index in ps_pages) and skip: # We were skipping pages but current page shouldn't be skipped. # Add this page to -pp, it could stay alone or become the # start of a range. pages_parameter += str(index) # Save the starting index to avoid things such as "11-11" last = index # We're not skipping anymore skip = False elif (index in ps_pages) and (not skip): # We weren't skipping but current page should be skipped if last != index - 1: # If the start index of the range is the previous page # then it's not a range pages_parameter += "-" + str(index - 1) # Add a separator pages_parameter += "," # Now we're skipping skip = True # Remove the trailing separator pages_parameter = pages_parameter.rstrip(",") # We've to manage the case in which the last page is closing a range if (not index in ps_pages) and (not skip) and (last != index): pages_parameter += "-" + str(index) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, dpi, fg_color, bg_color, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status != None: warning("%s failed to generate images from %s ... looking for PDF" \ % (os.path.basename(dvipng), dvi_file)) # FIXME: skip unnecessary dvips trial in legacy_conversion_step2 return legacy_conversion_step2(latex_file, dpi, output_format) if len(ps_pages) > 0: # Some pages require PostScript. # Create a new LaTeX file just for the snippets needing # the legacy method original_latex = open(latex_file, "r") legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) legacy_latex = open(legacy_latex_file, "w") page_index = 0 skip_page = False for line in original_latex: if line.startswith("\\begin{preview}"): page_index += 1 # Skips all pages processed by dvipng skip_page = page_index not in ps_pages if not skip_page: legacy_latex.write(line) if line.startswith("\\end{preview}"): skip_page = False legacy_latex.close() original_latex.close() # Pass the new LaTeX file to the legacy method vec = [ argv[0], latex_file_re.sub("_legacy.tex", argv[2]), \ argv[3], argv[1], argv[4], argv[5], latex ] legacy_conversion(vec, True) # Now we need to mix metrics data from dvipng and the legacy method metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) legacy_metrics = legacy_extract_metrics_info(latex_file_re.sub("_legacy.log", latex_file)) # Check whether a page is present in dvipng_metrics, otherwise # add it getting the metrics from legacy_metrics legacy_index = -1; for i in range(page_index): # If we exceed the array bounds or the dvipng_metrics doesn't # match the current one, this page belongs to the legacy method if (i > len(dvipng_metrics) - 1) or (dvipng_metrics[i][0] != str(i + 1)): legacy_index += 1 # Add this metric from the legacy output dvipng_metrics.insert(i, (str(i + 1), legacy_metrics[legacy_index][1])) # Legacy output filename legacy_output = os.path.join(dir, latex_file_re.sub("_legacy%s.%s" % (legacy_metrics[legacy_index][0], output_format), latex_file)) # Check whether legacy method actually created the file if os.path.isfile(legacy_output): # Rename the file by removing the "_legacy" suffix # and adjusting the index bitmap_output = os.path.join(dir, latex_file_re.sub("%s.%s" % (str(i + 1), output_format), latex_file)) os.rename(legacy_output, bitmap_output) # Actually create the .metrics file write_metrics_info(dvipng_metrics, metrics_file) else: # Extract metrics info from dvipng_stdout. # In this case we just used dvipng, so no special metrics # handling is needed. metrics_file = latex_file_re.sub(".metrics", latex_file) write_metrics_info(extract_metrics_info(dvipng_stdout), metrics_file) # Convert images to ppm format if necessary. if output_format == "ppm": convert_to_ppm_format(pngtopnm, latex_file_re.sub("", latex_file)) return 0
fg_color, bg_color, latex, pdf_output) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe(["pngtopnm"]) if pngtopnm == None: progress("Using the legacy conversion method (pngtopnm not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Compile the latex file. error_pages = [] latex_status, latex_stdout = run_latex(latex, latex_file, bibtex) if latex_status: warning("trying to recover from failed compilation") error_pages = check_latex_log(latex_file_re.sub(".log", latex_file)) # The dvi output file name dvi_file = latex_file_re.sub(".dvi", latex_file) # If there's no DVI output, look for PDF and go to legacy or fail if not os.path.isfile(dvi_file): # No DVI, is there a PDF? pdf_file = latex_file_re.sub(".pdf", latex_file) if os.path.isfile(pdf_file): progress("%s produced a PDF output, fallback to legacy." \ % (os.path.basename(latex))) progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, True)
def legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, use_pdftocairo, conv, gs_device, gs_ext, alpha, resolution, output_format): error_count = 0 # Search for pdflatex executable pdflatex = find_exe(["pdflatex"]) if pdflatex == None: warning( "Can't find pdflatex. Some pages failed with all the possible routes." ) failed_pages = [] else: # Create a new LaTeX file from the original but only with failed pages pdf_latex_file = latex_file_re.sub("_pdflatex.tex", latex_file) filter_pages(latex_file, pdf_latex_file, failed_pages) # pdflatex call error_pages = [] pdflatex_status, pdflatex_stdout = run_latex(pdflatex, pdf_latex_file) if pdflatex_status: error_pages = check_latex_log( latex_file_re.sub(".log", pdf_latex_file)) pdf_file = latex_file_re.sub(".pdf", pdf_latex_file) latex_file_root = latex_file_re.sub("", pdf_latex_file) # Converter call to produce bitmaps if use_pdftocairo: conv_call = '%s -png -transp -r %d "%s" "%s"' \ % (conv, resolution, pdf_file, latex_file_root) conv_status, conv_stdout = run_command(conv_call) if not conv_status: seqnum_re = re.compile("-([0-9]+)") for name in glob.glob("%s-*.png" % latex_file_root): match = seqnum_re.search(name) if match != None: new_name = seqnum_re.sub(str(int(match.group(1))), name) os.rename(name, new_name) else: conv_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (conv, gs_device, latex_file_root, \ gs_ext, alpha, alpha, resolution, pdf_file) conv_status, conv_stdout = run_command(conv_call) if conv_status: # Give up! warning("Some pages failed with all the possible routes") failed_pages = [] else: # We've done it! pdf_log_file = latex_file_re.sub(".log", pdf_latex_file) pdf_metrics = legacy_extract_metrics_info(pdf_log_file) # Invalidate metrics for pages that produced errors if len(error_pages) > 0: for index in error_pages: pdf_metrics.pop(index - 1) pdf_metrics.insert(index - 1, (index, -1.0)) error_count += 1 original_bitmap = latex_file_re.sub("%d." + output_format, pdf_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join the metrics with the those from dvips and rename the bitmap images join_metrics_and_rename(legacy_metrics, pdf_metrics, failed_pages, original_bitmap, destination_bitmap) return error_count
def legacy_conversion_step2(latex_file, dpi, output_format): # External programs used by the script. path = string.split(os.environ["PATH"], os.pathsep) dvips = find_exe_or_terminate(["dvips"], path) gs = find_exe_or_terminate(["gswin32c", "gs"], path) pnmcrop = find_exe(["pnmcrop"], path) # Run the dvi file through dvips. dvi_file = latex_file_re.sub(".dvi", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) pdf_file = latex_file_re.sub(".pdf", latex_file) dvips_call = '%s -o "%s" "%s"' % (dvips, ps_file, dvi_file) dvips_failed = False dvips_status, dvips_stdout = run_command(dvips_call) if dvips_status != None: warning('Failed: %s %s ... looking for PDF' \ % (os.path.basename(dvips), dvi_file)) dvips_failed = True # Extract resolution data for gs from the log file. log_file = latex_file_re.sub(".log", latex_file) resolution = extract_resolution(log_file, dpi) # Older versions of gs have problems with a large degree of # anti-aliasing at high resolutions alpha = 4 if resolution > 150: alpha = 2 gs_device = "png16m" gs_ext = "png" if output_format == "ppm": gs_device = "pnmraw" gs_ext = "ppm" # Generate the bitmap images gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_re.sub("", latex_file), \ gs_ext, alpha, alpha, resolution, ps_file) if dvips_failed: gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_re.sub("", latex_file), \ gs_ext, alpha, alpha, resolution, pdf_file) gs_status, gs_stdout = run_command(gs_call) if gs_status != None: error("Failed: %s %s" % (os.path.basename(gs), ps_file)) # Crop the images if pnmcrop != None: crop_files(pnmcrop, latex_file_re.sub("", latex_file)) # Extract metrics info from the log file. metrics_file = latex_file_re.sub(".metrics", latex_file) if not extract_metrics_info(log_file, metrics_file): error("Failed to extract metrics info from %s" % log_file) return 0
fg_color, bg_color, latex, pdf_output) elif len(pdf_pages) == page_count: progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, "pdflatex", True) # Retrieve resolution resolution = extract_resolution(latex_log, dpi) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, resolution, fg_color_dvipng, bg_color_dvipng, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status: warning("%s failed to generate images from %s... fallback to legacy method" \ % (os.path.basename(dvipng), dvi_file)) progress("Using the legacy conversion method (dvipng failed)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) # If some pages require PostScript pass them to legacy method if len(ps_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, ps_pages)
def legacy_conversion_step3(latex_file, dpi, output_format, dvips_failed, skipMetrics=False): # External programs used by the script. gs = find_exe_or_terminate(["gswin32c", "gswin64c", "gs"]) pnmcrop = find_exe(["pnmcrop"]) pdftocairo = find_exe(["pdftocairo"]) epstopdf = find_exe(["epstopdf"]) use_pdftocairo = pdftocairo != None and output_format == "png" if use_pdftocairo and os.name == 'nt': # On Windows, check for png support (see #10718) conv_status, conv_stdout = run_command("%s --help" % pdftocairo) use_pdftocairo = '-png' in conv_stdout if use_pdftocairo: conv = pdftocairo else: conv = gs # Files to process pdf_file = latex_file_re.sub(".pdf", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) # The latex file name without extension latex_file_root = latex_file_re.sub("", latex_file) # Extract resolution data for the converter from the log file. log_file = latex_file_re.sub(".log", latex_file) resolution = extract_resolution(log_file, dpi) # Check whether some pages produced errors error_pages = check_latex_log(log_file) # Older versions of gs have problems with a large degree of # anti-aliasing at high resolutions alpha = 4 if resolution > 150: alpha = 2 gs_device = "png16m" gs_ext = "png" if output_format == "ppm": gs_device = "pnmraw" gs_ext = "ppm" # Extract the metrics from the log file legacy_metrics = legacy_extract_metrics_info(log_file) # List of pages which failed to produce a correct output failed_pages = [] # Generate the bitmap images if dvips_failed: # dvips failed, maybe there's a PDF, try to produce bitmaps if use_pdftocairo: conv_call = '%s -png -transp -r %d "%s" "%s"' \ % (pdftocairo, resolution, pdf_file, latex_file_root) conv_status, conv_stdout = run_command(conv_call) if not conv_status: seqnum_re = re.compile("-([0-9]+)") for name in glob.glob("%s-*.png" % latex_file_root): match = seqnum_re.search(name) if match != None: new_name = seqnum_re.sub(str(int(match.group(1))), name) os.rename(name, new_name) else: conv_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_root, \ gs_ext, alpha, alpha, resolution, pdf_file) conv_status, conv_stdout = run_command(conv_call) if conv_status: error("Failed: %s %s" % (os.path.basename(conv), pdf_file)) else: # Model for calling the converter on each file if use_pdftocairo and epstopdf != None: conv_call = '%s -png -transp -singlefile -r %d "%%s" "%s%%d"' \ % (pdftocairo, resolution, latex_file_root) else: conv_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%%s"' \ % (gs, gs_device, latex_file_root, \ gs_ext, alpha, alpha, resolution) i = 0 # Collect all the PostScript files (like *.001, *.002, ...) ps_files = glob.glob("%s.[0-9][0-9][0-9]" % latex_file_root) ps_files.sort() # Call the converter for each file for file in ps_files: i = i + 1 progress("Processing page %s, file %s" % (i, file)) if use_pdftocairo and epstopdf != None: conv_name = "epstopdf" conv_status, conv_stdout = run_command( "%s --outfile=%s.pdf %s" % (epstopdf, file, file)) if not conv_status: conv_name = "pdftocairo" file = file + ".pdf" conv_status, conv_stdout = run_command(conv_call % (file, i)) else: conv_name = "ghostscript" conv_status, conv_stdout = run_command(conv_call % (i, file)) if conv_status: # The converter failed, keep track of this warning("%s failed on page %s, file %s" % (conv_name, i, file)) failed_pages.append(i) # Pass failed pages to pdflatex if len(failed_pages) > 0: warning("Now trying to obtain failed previews through pdflatex") error_count = legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, use_pdftocairo, conv, gs_device, gs_ext, alpha, resolution, output_format) else: error_count = 0 # Invalidate metrics for pages that produced errors if len(error_pages) > 0: for index in error_pages: if index not in failed_pages: legacy_metrics.pop(index - 1) legacy_metrics.insert(index - 1, (index, -1.0)) error_count += 1 # Crop the ppm images if pnmcrop != None and output_format == "ppm": crop_files(pnmcrop, latex_file_root) # Allow to skip .metrics creation for custom management # (see the dvipng method) if not skipMetrics: # Extract metrics info from the log file. metrics_file = latex_file_re.sub(".metrics", latex_file) write_metrics_info(legacy_metrics, metrics_file) if error_count: warning("Failed to produce %d preview snippet(s)" % error_count) return (0, legacy_metrics)
def legacy_conversion_step3(latex_file, dpi, output_format, dvips_failed, skipMetrics=False): # External programs used by the script. gs = find_exe_or_terminate(["gswin32c", "gswin64c", "gs"]) pnmcrop = find_exe(["pnmcrop"]) # Files to process pdf_file = latex_file_re.sub(".pdf", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) # Extract resolution data for gs from the log file. log_file = latex_file_re.sub(".log", latex_file) resolution = extract_resolution(log_file, dpi) # Older versions of gs have problems with a large degree of # anti-aliasing at high resolutions alpha = 4 if resolution > 150: alpha = 2 gs_device = "png16m" gs_ext = "png" if output_format == "ppm": gs_device = "pnmraw" gs_ext = "ppm" # Extract the metrics from the log file legacy_metrics = legacy_extract_metrics_info(log_file) # List of pages which failed to produce a correct output failed_pages = [] # Generate the bitmap images if dvips_failed: # dvips failed, maybe there's a PDF, try to produce bitmaps gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_re.sub("", latex_file), \ gs_ext, alpha, alpha, resolution, pdf_file) gs_status, gs_stdout = run_command(gs_call) if gs_status: error("Failed: %s %s" % (os.path.basename(gs), ps_file)) else: # Model for calling gs on each file gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%%s"' \ % (gs, gs_device, latex_file_re.sub("", latex_file), \ gs_ext, alpha, alpha, resolution) i = 0 # Collect all the PostScript files (like *.001, *.002, ...) ps_files = glob.glob("%s.[0-9][0-9][0-9]" % latex_file_re.sub("", latex_file)) ps_files.sort() # Call GhostScript for each file for file in ps_files: i = i + 1 progress("Processing page %s, file %s" % (i, file)) gs_status, gs_stdout = run_command(gs_call % (i, file)) if gs_status: # gs failed, keep track of this warning("Ghostscript failed on page %s, file %s" % (i, file)) failed_pages.append(i) # Pass failed pages to pdflatex if len(failed_pages) > 0: legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, gs, gs_device, gs_ext, alpha, resolution, output_format) # Crop the images if pnmcrop != None: crop_files(pnmcrop, latex_file_re.sub("", latex_file)) # Allow to skip .metrics creation for custom management # (see the dvipng method) if not skipMetrics: # Extract metrics info from the log file. metrics_file = latex_file_re.sub(".metrics", latex_file) write_metrics_info(legacy_metrics, metrics_file) return (0, legacy_metrics)
def legacy_conversion_step2(latex_file, dpi, output_format, skipMetrics = False): # External programs used by the script. dvips = find_exe_or_terminate(["dvips"], path) gs = find_exe_or_terminate(["gswin32c", "gs"], path) pnmcrop = find_exe(["pnmcrop"], path) # Run the dvi file through dvips. dvi_file = latex_file_re.sub(".dvi", latex_file) ps_file = latex_file_re.sub(".ps", latex_file) pdf_file = latex_file_re.sub(".pdf", latex_file) dvips_call = '%s -i -o "%s" "%s"' % (dvips, ps_file, dvi_file) dvips_failed = False dvips_status, dvips_stdout = run_command(dvips_call) if dvips_status != None: warning('Failed: %s %s ... looking for PDF' \ % (os.path.basename(dvips), dvi_file)) dvips_failed = True # Extract resolution data for gs from the log file. log_file = latex_file_re.sub(".log", latex_file) resolution = extract_resolution(log_file, dpi) # Older versions of gs have problems with a large degree of # anti-aliasing at high resolutions alpha = 4 if resolution > 150: alpha = 2 gs_device = "png16m" gs_ext = "png" if output_format == "ppm": gs_device = "pnmraw" gs_ext = "ppm" # Extract the metrics from the log file legacy_metrics = legacy_extract_metrics_info(log_file) # List of pages which failed to produce a correct output failed_pages = [] # Generate the bitmap images if dvips_failed: # dvips failed, maybe there's a PDF, try to produce bitmaps gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%s"' \ % (gs, gs_device, latex_file_re.sub("", latex_file), \ gs_ext, alpha, alpha, resolution, pdf_file) gs_status, gs_stdout = run_command(gs_call) if gs_status != None: error("Failed: %s %s" % (os.path.basename(gs), ps_file)) else: # Model for calling gs on each file gs_call = '%s -dNOPAUSE -dBATCH -dSAFER -sDEVICE=%s ' \ '-sOutputFile="%s%%d.%s" ' \ '-dGraphicsAlphaBit=%d -dTextAlphaBits=%d ' \ '-r%f "%%s"' \ % (gs, gs_device, latex_file_re.sub("", latex_file), \ gs_ext, alpha, alpha, resolution) i = 0 # Collect all the PostScript files (like *.001, *.002, ...) ps_files = glob.glob("%s.[0-9][0-9][0-9]" % latex_file_re.sub("", latex_file)) ps_files.sort() # Call GhostScript for each file for file in ps_files: i = i + 1 gs_status, gs_stdout = run_command(gs_call % (i, file)) if gs_status != None: # gs failed, keep track of this failed_pages.append(i) # Pass failed pages to pdflatex if len(failed_pages) > 0: legacy_conversion_pdflatex(latex_file, failed_pages, legacy_metrics, gs, gs_device, gs_ext, alpha, resolution, output_format) # Crop the images if pnmcrop != None: crop_files(pnmcrop, latex_file_re.sub("", latex_file)) # Allow to skip .metrics creation for custom management # (see the dvipng method) if not skipMetrics: # Extract metrics info from the log file. metrics_file = latex_file_re.sub(".metrics", latex_file) write_metrics_info(legacy_metrics, metrics_file) return (0, legacy_metrics)
def main(argv): # Set defaults. dpi = 128 fg_color = "000000" bg_color = "ffffff" bibtex = None latex = None lilypond = False lilypond_book = None output_format = "png" script_name = argv[0] # Parse and manipulate the command line arguments. try: (opts, args) = getopt.gnu_getopt(argv[1:], "dhv", [ "bibtex=", "bg=", "debug", "dpi=", "fg=", "help", "latex=", "lilypond", "lilypond-book=", "png", "ppm", "verbose" ]) except getopt.GetoptError as err: error("%s\n%s" % (err, usage(script_name))) opts.reverse() for opt, val in opts: if opt in ("-h", "--help"): print(usage(script_name)) sys.exit(0) elif opt == "--bibtex": bibtex = [val] elif opt == "--bg": bg_color = val elif opt in ("-d", "--debug"): lyxpreview_tools.debug = True elif opt == "--dpi": try: dpi = int(val) except: error("Cannot convert %s to an integer value" % val) elif opt == "--fg": fg_color = val elif opt == "--latex": latex = [val] elif opt == "--lilypond": lilypond = True elif opt == "--lilypond-book": lilypond_book = [val] elif opt in ("--png", "--ppm"): output_format = opt[2:] elif opt in ("-v", "--verbose"): lyxpreview_tools.verbose = True # Determine input file if len(args) != 1: err = "A single input file is required, %s given" % (len(args) or "none") error("%s\n%s" % (err, usage(script_name))) input_path = args[0] dir, latex_file = os.path.split(input_path) # Check for the input file if not os.path.exists(input_path): error('File "%s" not found.' % input_path) if len(dir) != 0: os.chdir(dir) if lyxpreview_tools.verbose: f_out = open('verbose.txt', 'a') sys.stdout = f_out sys.stderr = f_out # Echo the settings progress("Running Python %s" % str(sys.version_info[:3])) progress("Starting %s..." % script_name) if os.name == "nt": progress("Use win32_modules: %d" % lyxpreview_tools.use_win32_modules) progress("Output format: %s" % output_format) progress("Foreground color: %s" % fg_color) progress("Background color: %s" % bg_color) progress("Resolution (dpi): %s" % dpi) progress("File to process: %s" % input_path) # For python > 2 convert strings to bytes if not PY2: fg_color = bytes(fg_color, 'ascii') bg_color = bytes(bg_color, 'ascii') fg_color_dvipng = make_texcolor(fg_color, False) bg_color_dvipng = make_texcolor(bg_color, False) # For python > 2 convert bytes to string if not PY2: fg_color_dvipng = fg_color_dvipng.decode('ascii') bg_color_dvipng = bg_color_dvipng.decode('ascii') # External programs used by the script. latex = find_exe_or_terminate(latex or latex_commands) bibtex = find_exe(bibtex or bibtex_commands) if lilypond: lilypond_book = find_exe_or_terminate(lilypond_book or ["lilypond-book --safe"]) # These flavors of latex are known to produce pdf output pdf_output = latex in pdflatex_commands progress("Latex command: %s" % latex) progress("Latex produces pdf output: %s" % pdf_output) progress("Bibtex command: %s" % bibtex) progress("Lilypond-book command: %s" % lilypond_book) progress("Preprocess through lilypond-book: %s" % lilypond) progress("Altering the latex file for font size and colors") # Make sure that multiple defined macros and the microtype package # don't cause issues in the latex file. fix_latex_file(latex_file, pdf_output) if lilypond: progress("Preprocess the latex file through %s" % lilypond_book) if pdf_output: lilypond_book += " --pdf" lilypond_book += " --latex-program=%s" % latex.split()[0] # Make a copy of the latex file lytex_file = latex_file_re.sub(".lytex", latex_file) shutil.copyfile(latex_file, lytex_file) # Preprocess the latex file through lilypond-book. lytex_status, lytex_stdout = run_tex(lilypond_book, lytex_file) if pdf_output: progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # This can go once dvipng becomes widespread. dvipng = find_exe(["dvipng"]) if dvipng == None: progress("Using the legacy conversion method (dvipng not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) dv2dt = find_exe(["dv2dt"]) if dv2dt == None: progress("Using the legacy conversion method (dv2dt not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) pngtopnm = "" if output_format == "ppm": pngtopnm = find_exe(["pngtopnm"]) if pngtopnm == None: progress("Using the legacy conversion method (pngtopnm not found)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Compile the latex file. error_pages = [] latex_status, latex_stdout = run_latex(latex, latex_file, bibtex) latex_log = latex_file_re.sub(".log", latex_file) if latex_status: progress("Will try to recover from %s failure" % latex) error_pages = check_latex_log(latex_log) # The dvi output file name dvi_file = latex_file_re.sub(".dvi", latex_file) # If there's no DVI output, look for PDF and go to legacy or fail if not os.path.isfile(dvi_file): # No DVI, is there a PDF? pdf_file = latex_file_re.sub(".pdf", latex_file) if os.path.isfile(pdf_file): progress("%s produced a PDF output, fallback to legacy." \ % (os.path.basename(latex))) progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, True) else: error("No DVI or PDF output. %s failed." \ % (os.path.basename(latex))) # Look for PS literals or inclusion of pdflatex files in DVI pages # ps_pages: list of indexes of pages containing PS literals # pdf_pages: list of indexes of pages requiring running pdflatex # page_count: total number of pages # pages_parameter: parameter for dvipng to exclude pages with PostScript (ps_pages, pdf_pages, page_count, pages_parameter) = find_ps_pages(dvi_file) # If all pages need PostScript or pdflatex, directly use the legacy method. if len(ps_pages) == page_count: progress("Using the legacy conversion method (PostScript support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) elif len(pdf_pages) == page_count: progress("Using the legacy conversion method (PDF support)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, "pdflatex", True) # Retrieve resolution resolution = extract_resolution(latex_log, dpi) # Run the dvi file through dvipng. dvipng_call = '%s -Ttight -depth -height -D %d -fg "%s" -bg "%s" %s "%s"' \ % (dvipng, resolution, fg_color_dvipng, bg_color_dvipng, pages_parameter, dvi_file) dvipng_status, dvipng_stdout = run_command(dvipng_call) if dvipng_status: warning("%s failed to generate images from %s... fallback to legacy method" \ % (os.path.basename(dvipng), dvi_file)) progress("Using the legacy conversion method (dvipng failed)") return legacy_conversion_step1(latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output) # Extract metrics info from dvipng_stdout. metrics_file = latex_file_re.sub(".metrics", latex_file) dvipng_metrics = extract_metrics_info(dvipng_stdout) # If some pages require PostScript pass them to legacy method if len(ps_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, ps_pages) # Pass the new LaTeX file to the legacy method progress("Pages %s include postscript specials" % ps_pages) progress("Using the legacy conversion method (PostScript support)") legacy_status, legacy_metrics = legacy_conversion_step1( legacy_latex_file, dpi, output_format, fg_color, bg_color, latex, pdf_output, True) # Now we need to mix metrics data from dvipng and the legacy method original_bitmap = latex_file_re.sub("%d." + output_format, legacy_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join metrics from dvipng and legacy, and rename legacy bitmaps join_metrics_and_rename(dvipng_metrics, legacy_metrics, ps_pages, original_bitmap, destination_bitmap) # If some pages require running pdflatex pass them to legacy method if len(pdf_pages) > 0: # Create a new LaTeX file just for the snippets needing # the legacy method legacy_latex_file = latex_file_re.sub("_legacy.tex", latex_file) filter_pages(latex_file, legacy_latex_file, pdf_pages) # Pass the new LaTeX file to the legacy method progress("Pages %s require processing with pdflatex" % pdf_pages) progress("Using the legacy conversion method (PDF support)") legacy_status, legacy_metrics = legacy_conversion_step1( legacy_latex_file, dpi, output_format, fg_color, bg_color, "pdflatex", True, True) # Now we need to mix metrics data from dvipng and the legacy method original_bitmap = latex_file_re.sub("%d." + output_format, legacy_latex_file) destination_bitmap = latex_file_re.sub("%d." + output_format, latex_file) # Join metrics from dvipng and legacy, and rename legacy bitmaps join_metrics_and_rename(dvipng_metrics, legacy_metrics, pdf_pages, original_bitmap, destination_bitmap) # Invalidate metrics for pages that produced errors if len(error_pages) > 0: error_count = 0 for index in error_pages: if index not in ps_pages and index not in pdf_pages: dvipng_metrics.pop(index - 1) dvipng_metrics.insert(index - 1, (index, -1.0)) error_count += 1 if error_count: warning("Failed to produce %d preview snippet(s)" % error_count) # Convert images to ppm format if necessary. if output_format == "ppm": convert_to_ppm_format(pngtopnm, latex_file_re.sub("", latex_file)) # Actually create the .metrics file write_metrics_info(dvipng_metrics, metrics_file) return (0, dvipng_metrics)