annotate pyspark/dml-analyser.py @ 0:e34cf1b6fe09 tip

commit

# Part of DML (Digital Music Laboratory)
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__="hargreavess"

import ConfigParser
import logging
import os
import time
import shutil
import argparse
from os import walk
import rdflib
from rdflib import Graph
from RDFClosure import DeductiveClosure, OWLRL_Semantics
from transforms.tonicHistogram import find_cla_tonic_histogram, add_tonic_histogram_to_graph
from transforms.tuningFrequencyStatistics import find_cla_tf_statistics, add_tf_statistics_to_graph
from transforms.semitoneHistogram import find_cla_semitone_histogram, add_semitone_histogram_to_graph
from transforms.tonicNormSemitoneHistogram import find_cla_tonic_norm_semitone_histogram, add_tonic_norm_semitone_histogram_to_graph

input_rdf_graph = Graph()

def main():

    # get config
    config = ConfigParser.ConfigParser()
    config.read('dml-analyser.cfg')

    # parse dmlcla ontolgy
    input_rdf_graph.parse(config.get('Ontology', 'dmlclaOntology_URI'), format="n3")
    DeductiveClosure(OWLRL_Semantics).expand(input_rdf_graph)

    # parse input rdf
    input_rdf_graph.parse(args.transforms, format="n3")
    DeductiveClosure(OWLRL_Semantics).expand(input_rdf_graph)

    # initialise output rdf graph
    output_rdf_graph = Graph()

    # Determine which transforms are to be applied, and
    # the associated input files
    transforms = find_transforms_in_n3(input_rdf_graph)

    # Apply the transform(s) to each file and create 
    # rdf results graph
    output_rdf_graph = execute_transforms(transforms, output_rdf_graph)

    # Write output rdf to stdout
    print(output_rdf_graph.serialize(format='n3'))

# Loop through all transforms, process the corresponding
# input files appropriately and add the (RDF) result to output_rdf_graph
def execute_transforms(transforms, output_rdf_graph):

    transform_iter = transforms.iterkeys()
    key_histogram = []

    for (transform, transform_type) in transforms:

        input_f_files = transforms.get((transform, transform_type))

        # Add additional clauses to this if statement
        # for each transform type
        if transform_type == rdflib.term.URIRef(u'http://dml.org/dml/cla#CollectionLevelTonic'):

            (tonic_histogram, sample_count) = find_cla_tonic_histogram(input_f_files)
            output_rdf_graph = add_tonic_histogram_to_graph(tonic_histogram, output_rdf_graph, transform, sample_count, input_f_files)
            
        elif transform_type == rdflib.term.URIRef(u'http://dml.org/dml/cla#CollectionLevelTuningFrequencyStatistics'):

            statistics, sample_count = find_cla_tf_statistics(input_f_files)
            output_rdf_graph = add_tf_statistics_to_graph(statistics, output_rdf_graph, transform, sample_count, input_f_files)

        elif transform_type == rdflib.term.URIRef(u'http://dml.org/dml/cla#CollectionLevelSemitone'):

            (semitone_histogram, sample_count) = find_cla_semitone_histogram(input_f_files)
            output_rdf_graph = add_semitone_histogram_to_graph(semitone_histogram, output_rdf_graph, transform, sample_count, input_f_files)

        elif transform_type == rdflib.term.URIRef(u'http://dml.org/dml/cla#CollectionLevelTonicNormSemitone'):

            (tonic_norm_semitone_histogram, sample_count) = find_cla_tonic_norm_semitone_histogram(input_f_files, input_rdf_graph)
            output_rdf_graph = add_tonic_norm_semitone_histogram_to_graph(tonic_norm_semitone_histogram, output_rdf_graph, transform, sample_count, input_f_files, input_rdf_graph)

    return output_rdf_graph

# Find all transforms, and their associated input files,
# from rdf_graph
def find_transforms_in_n3(rdf_graph):

    qres = rdf_graph.query(
        """prefix dml:     <http://dml.org/dml/cla#>
            SELECT ?transform ?dml_input ?transform_type
            WHERE {
                ?transform a dml:Transform .
                ?transform dml:input ?dml_input .
                ?transform dml:type ?transform_type .
            }""")

    transforms = dict()
    
    for row in qres:

        transform_bnode = row.transform
        dml_input = row.dml_input
        transform_type = row.transform_type

        if transforms.has_key((transform_bnode, transform_type)):

            transform_key = transforms.get((transform_bnode, transform_type))
            transform_key.append(dml_input)

        else:

            transforms[(transform_bnode, transform_type)] = [dml_input]

    return transforms

# Determine the mapping between feature file URIs and
# their source audio file URIs
def map_audio_to_feature_files():    

    # Loop through audio files
    lines = [line.strip() for line in args.audio_files]

    for audio_file in lines:

        print "sonic-annotator -T " + args.transforms + " --rdf-basedir " + args.basedir + " <" + audio_file + ">"

    audio_to_feature_file_dict = dict()

    for (dirpath, dirnames, filenames) in walk(args.basedir):
        for file in filenames:

            print "found file: " + file

            if file.endswith(".n3"):

                print "found n3 file: " + file

                # open and parse n3 file
                rdf_graph = Graph()
                rdf_graph.parse(os.path.join(dirpath, file), format="n3")

                # find subject in ?subject a mo:AudioFile
                qres = rdf_graph.query(
                    """SELECT ?audio_file
                       WHERE {
                          ?audio_file a mo:AudioFile .
                       }""")

                print len(qres)

                for row in qres:

                    print("audio file URI is %s" % row.audio_file.n3())
                    print("feature file URI is %s" % os.path.join(os.getcwd(), dirpath, file))
                    audio_to_feature_file_dict[row.audio_file.n3()] = os.path.join(os.getcwd(), dirpath, file)

                # add full file URI, subject to dict

    print audio_to_feature_file_dict

if __name__ == "__main__":

    parser = argparse.ArgumentParser()

    parser.add_argument("-T", "--transforms", help="the URI of an n3 (RDF) file describing one or more transforms, and the files to which they should be applied")
    parser.add_argument("-b", "--basedir", help="the URI of the base output directory")

    args = parser.parse_args()

    main()