Exemple #1
0
def graph(expr, image_format='pdf', layout='dot'):
    r'''Graphs `expr` with graphviz and opens resulting image in 
    the default image viewer.

    ::

        >>> rtm_syntax = '(3 ((2 (2 1)) 2))'
        >>> rhythm_tree = rhythmtreetools.RhythmTreeParser()(rtm_syntax)[0]
        >>> print rhythm_tree.pretty_rtm_format
        (3 (
            (2 (
                2
                1))
            2))

    ::

        >>> iotools.graph(rhythm_tree) # doctest: +SKIP

    Returns none.
    '''
    from abjad import abjad_configuration
    from abjad.tools import iotools

    assert image_format in ('pdf', 'png')
    layouts =('circo', 'dot', 'fdp', 'neato', 'osage', 'sfdp', 'twopi')
    assert layout in layouts
    message = 'Cannot find `{}` command-line tool.'.format(layout)
    message += ' Please download Graphviz from graphviz.org.'
    assert iotools.which(layout), message

    if isinstance(expr, str):
        graphviz_format = expr
    else:
        graphviz_format = expr.graphviz_format

    current_directory = os.path.abspath('.')
    ABJADOUTPUT = abjad_configuration['abjad_output']
    iotools.verify_output_directory(ABJADOUTPUT)
    dot_path = os.path.join(
        ABJADOUTPUT,
        iotools.get_next_output_file_name(file_extension='dot'),
        )
    img_path = os.path.join(ABJADOUTPUT, dot_path.replace('dot', 'pdf'))

    with open(dot_path, 'w') as f:
        f.write(graphviz_format)

    command = '{} -v -T{} {} -o {}'
    command = command.format(layout, image_format, dot_path, img_path)
    subprocess.call(command, shell=True)

    pdf_viewer = abjad_configuration['pdf_viewer']
    ABJADOUTPUT = abjad_configuration['abjad_output']
    iotools.open_file(img_path, pdf_viewer)
Exemple #2
0
 def unflattened_graphviz_format(self):
     from abjad.tools import iotools
     assert iotools.which(
         'unflatten'), 'Cannot find `unflatten` command-line tool.'
     graphviz_format = self.graphviz_format
     process = subprocess.Popen('unflatten -l 4'.split(),
         shell=False,
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE
         )
     result = process.communicate(graphviz_format)[0]
     return result
Exemple #3
0
def plot(expr, image_format='png', width=640, height=320):
    r'''Plots `expr` with gnuplot and opens resulting image in 
    the default image viewer.

    Returns none.
    '''

    from abjad import abjad_configuration
    from abjad.tools import iotools

    assert image_format in ('pdf', 'png')
    assert isinstance(width, int) and 0 < width
    assert isinstance(height, int) and 0 < height
    message = 'Cannot find `gnuplot` command-line tool.'
    assert iotools.which('gnuplot'), message

    gnuplot_format = expr.gnuplot_format

    current_directory = os.path.abspath('.')
    abjad_output = abjad_configuration['abjad_output']
    iotools.verify_output_directory(abjad_output)
    txt_path = os.path.join(
        abjad_output, iotools.get_next_output_file_name(file_extension='txt'))
    img_path = os.path.join(abjad_output, txt_path.replace('txt', image_format))

    if image_format == 'png':
        image_format = 'pngcairo'

    gnuplot_format = gnuplot_format.format(
        filename=img_path,
        image_format=image_format,
        height=height,
        width=width
        )

    with open(txt_path, 'w') as f:
        f.write(gnuplot_format)

    command = 'gnuplot {}'.format(txt_path)
    subprocess.call(command, shell=True)

    pdf_viewer = abjad_configuration['pdf_viewer']
    abjad_output = abjad_configuration['abjad_output']
    iotools.open_file(img_path, pdf_viewer)
Exemple #4
0
def compare_images(image_one, image_two):
    r'''Compare `image_one` against `image_two` using ImageMagick's `compare`
    commandline tool.

    Return `True` if images are the same, otherwise `False`.

    If `compare` is not available, return `False`.
    '''
    import tempfile
    from abjad.tools import iotools

    assert os.path.exists(image_one)
    assert os.path.exists(image_two)

    result = False

    if iotools.which('compare'):

        tempdir = tempfile.mkdtemp()
        comparison = os.path.join(tempdir, 'comparison.png')

        command = 'compare -metric ae {} {} {}'.format(
            image_one, image_two, comparison)
        process = subprocess.Popen(command.split(),
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
            )

        stderr = process.stderr.read()
        stdout = process.stdout.read()

        if stderr:
            part = stderr.split()[0]
            if part.isdigit():
                result = int(part) is 0
        elif stdout:
            part = stdout.split()[0]
            if part.isdigit():
                result = int(part) is 0

        shutil.rmtree(tempdir)

    return result