output.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
#include <assert.h>
#include <errno.h>
#include <string.h>

#include <libxml/tree.h>

#ifdef HAPLO_HAVE_DMALLOC
#include <dmalloc.h>
#endif

#include <jwsc/base/error.h>
#include <jwsc/vector/vector.h>
#include <jwsc/matblock/matblock.h>

#include "options.h"
#include "xml.h"
#include "haplo_groups.h"
#include "output.h"


Error* open_output
(
    FILE**      fp_out, 
    xmlDoc**    xml_doc_out, 
    const char* xml_name,
    const char* xml_dtd,
    const char* fname
)
{
    const char* fp_mode;
    int   slen = 256;
    char  str[slen];

    switch (opts.output_format)
    {
        case HAPLO_OUTPUT_TXT:
        case HAPLO_OUTPUT_CSV:
            fp_mode = (strcmp("/dev/stdout", fname) == 0) ? "a" : "w";
            if (!((*fp_out) = fopen(fname, fp_mode)))
            {
                snprintf(str, slen, "%s: %s", fname, strerror(errno));
                return JWSC_EIO(str);
            }
            break;
        case HAPLO_OUTPUT_XML:
            if (!xml_doc_out)
                return NULL;
            *xml_doc_out = xmlNewDoc((xmlChar*)"1.0");
            xmlDocSetRootElement(*xml_doc_out, XMLNewNode(xml_name));
            XMLCreateIntSubset(*xml_doc_out, xml_name, NULL, xml_dtd);
            break;
    }

    return NULL;
}


Error* close_output(FILE* fp, xmlDoc* xml_doc, const char* fname)
{
    int  slen = 256;
    char str[slen];

    switch (opts.output_format)
    {
        case HAPLO_OUTPUT_TXT:
        case HAPLO_OUTPUT_CSV:
            if (fclose(fp) != 0)
            {
                snprintf(str, slen, "%s: %s", fname, strerror(errno));
                return JWSC_EIO(str);
            }
            break;
        case HAPLO_OUTPUT_XML:
            if (!xml_doc)
                return NULL;
            if (xmlSaveFormatFile(fname, xml_doc, 1) <= 0)
            {
                snprintf(str, slen, "%s: %s", fname, strerror(errno));
                return JWSC_EIO(str);
            }
            xmlFreeDoc(xml_doc);
            xmlCleanupParser();
            break;
    }

    return NULL;
}

void write_ids
(
    const Matblock_u8* ids,
    uint32_t           i,
    Haplo_field_sep    field_sep,
    FILE*              fp,
    xmlNode*           xml_node
)
{
    uint32_t    j;
    const char* fmt;
    xmlNode*    xml_child = NULL;
    char*       xml_buf   = NULL;
    uint32_t    xml_len;

    if (!ids)
        return;

    for (j = 0; j < ids->num_rows; j++)
    {
        switch (opts.output_format)
        {
            case HAPLO_OUTPUT_TXT:
                switch (field_sep)
                {
                    case HAPLO_SEP_PREFIX:
                        fmt = "  %-10s"; break;
                    case HAPLO_SEP_SUFFIX:
                        fmt = "%-10s  "; break;
                    case HAPLO_SEP_BOTH:
                        fmt = "  %-10s  "; break;
                    case HAPLO_SEP_NONE:
                        fmt = "%-10s"; break;
                }
                fprintf(fp, fmt, ids->elts[ i ][ j ]);
                break;
            case HAPLO_OUTPUT_CSV:
                switch (field_sep)
                {
                    case HAPLO_SEP_PREFIX:
                        fmt = ",%s"; break;
                    case HAPLO_SEP_SUFFIX:
                        fmt = "%s,"; break;
                    case HAPLO_SEP_BOTH:
                        fmt = ",%s,"; break;
                    case HAPLO_SEP_NONE:
                        fmt = "%s"; break;
                }
                fprintf(fp, fmt, ids->elts[ i ][ j ]);
                break;
            case HAPLO_OUTPUT_XML:
                xml_len = strlen((char*)ids->elts[ i ][ j ]) + 256;
                xml_buf = malloc(xml_len*sizeof(char));
                snprintf(xml_buf, xml_len, "%s", ids->elts[ i ][ j ]);
                xml_child = XMLNewChild(xml_node, "id", xml_buf);
                snprintf(xml_buf, xml_len, "%d", j+1);
                XMLNewProp(xml_child, "number", xml_buf);
                free(xml_buf);
                break;
        }
    }
}

void write_label
(
    const Vector_u32* labels,
    uint32_t          i,
    Haplo_field_sep   field_sep,
    FILE*             fp,
    xmlNode*          xml_node
)
{
    const char* fmt;
    const char* label;
    char*       xml_buf = NULL;
    uint32_t    xml_len;

    if (!labels)
        return;

    assert(lookup_haplo_group_label_from_index(&label, labels->elts[ i ]) 
            == NULL);

    switch (opts.output_format)
    {
        case HAPLO_OUTPUT_TXT:
            switch (field_sep)
            {
                case HAPLO_SEP_PREFIX:
                    fmt = "  %-10s"; break;
                case HAPLO_SEP_SUFFIX:
                    fmt = "%-10s  "; break;
                case HAPLO_SEP_BOTH:
                    fmt = "  %-10s  "; break;
                case HAPLO_SEP_NONE:
                    fmt = "%-10s"; break;
            }
            fprintf(fp, fmt, label);
            break;
        case HAPLO_OUTPUT_CSV:
            switch (field_sep)
            {
                case HAPLO_SEP_PREFIX:
                    fmt = ",%s"; break;
                case HAPLO_SEP_SUFFIX:
                    fmt = "%s,"; break;
                case HAPLO_SEP_BOTH:
                    fmt = ",%s,"; break;
                case HAPLO_SEP_NONE:
                    fmt = "%s"; break;
            }
            fprintf(fp, fmt, label);
            break;
        case HAPLO_OUTPUT_XML:
            xml_len = strlen(label) + 1;
            xml_buf = malloc(xml_len*sizeof(char));
            snprintf(xml_buf, xml_len, "%s", label);
            XMLNewChild(xml_node, "label", xml_buf);
            free(xml_buf);
            break;
    }
}


void write_conf
(
    const Vector_d* confs,
    uint32_t        i,
    Haplo_field_sep field_sep,
    FILE*           fp,
    xmlNode*        xml_node
)
{
    double      conf;
    const char* fmt;
    char        xml_buf[256] = {0};

    if (!confs)
        return;

    conf = confs->elts[ i ];

    switch (opts.output_format)
    {
        case HAPLO_OUTPUT_TXT:
            switch (field_sep)
            {
                case HAPLO_SEP_PREFIX:
                    fmt = "  %-5.3f"; break;
                case HAPLO_SEP_SUFFIX:
                    fmt = "%-5.3f  "; break;
                case HAPLO_SEP_BOTH:
                    fmt = "  %-5.3f  "; break;
                case HAPLO_SEP_NONE:
                    fmt = "%-5.3f"; break;
            }
            fprintf(fp, fmt, conf);
            break;
        case HAPLO_OUTPUT_CSV:
            switch (field_sep)
            {
                case HAPLO_SEP_PREFIX:
                    fmt = ",%.3f"; break;
                case HAPLO_SEP_SUFFIX:
                    fmt = "%.3f,"; break;
                case HAPLO_SEP_BOTH:
                    fmt = ",%.3f,"; break;
                case HAPLO_SEP_NONE:
                    fmt = "%.3f"; break;
            }
            fprintf(fp, fmt, conf);
            break;
        case HAPLO_OUTPUT_XML:
            snprintf(xml_buf, 256, "%5.3f", conf);
            XMLNewChild(xml_node, "confidence", xml_buf);
            break;
    }
}


void write_prediction
(
    const char*       type,
    const Vector_u32* labels,
    const Vector_d*   confs,
    uint32_t          i,
    Haplo_field_sep   field_sep,
    FILE*             fp,
    xmlNode*          xml_node
)
{
    xmlNode* xml_child;

    if (!labels)
        return;

    if (opts.output_format == HAPLO_OUTPUT_XML)
    {
        xml_child = XMLNewChild(xml_node, "prediction", NULL);
        XMLNewProp(xml_child, "type", type);
    }

    write_label(labels, i, field_sep, fp, xml_child);
    write_conf(confs, i, field_sep, fp, xml_child);
}


void write_ancestor_label
(
    const Vector_u32*  ancestor_types,
    const Vector_u32*  ancestor_labels,
    uint32_t           i,
    Haplo_field_sep    field_sep,
    FILE*              fp,
    xmlNode*           xml_node
)
{
    uint32_t            ancestor;
    Haplo_ancestor_type type;
    const char*         fmt;
    const char*         label;
    xmlNode*            xml_child = NULL;
    char*               xml_buf   = NULL;
    uint32_t            xml_len;

    assert(ancestor_types && ancestor_labels);

    type = ancestor_types->elts[ i ];
    ancestor = ancestor_labels->elts[ i ];

    switch (type)
    {
        case HAPLO_ANCESTOR_INDIRECT:
            assert(lookup_haplo_group_label_from_index(&label, ancestor)==NULL);
            break;
        case HAPLO_ANCESTOR_DIRECT:
            assert(lookup_haplo_group_label_from_index(&label, ancestor)==NULL);
            break;
        case HAPLO_ANCESTOR_NONE:
            label = "NONE";
            break;
    }

    switch (opts.output_format)
    {
        case HAPLO_OUTPUT_TXT:
            switch (field_sep)
            {
                case HAPLO_SEP_PREFIX:
                    fmt = "  %-10s  %-4d"; break;
                case HAPLO_SEP_SUFFIX:
                    fmt = "%-10s  %-4d  "; break;
                case HAPLO_SEP_BOTH:
                    fmt = "  %-10s  %-4d  "; break;
                case HAPLO_SEP_NONE:
                    fmt = "%-10s  %-4d"; break;
            }
            fprintf(fp, fmt, label, type);
            break;
        case HAPLO_OUTPUT_CSV:
            switch (field_sep)
            {
                case HAPLO_SEP_PREFIX:
                    fmt = ",%s,%d"; break;
                case HAPLO_SEP_SUFFIX:
                    fmt = "%s,%d,"; break;
                case HAPLO_SEP_BOTH:
                    fmt = ",%s,%d,"; break;
                case HAPLO_SEP_NONE:
                    fmt = "%s,%d"; break;
            }
            fprintf(fp, fmt, label, type);
            break;
        case HAPLO_OUTPUT_XML:
            xml_len = strlen(label) + 9;
            xml_buf = malloc(xml_len*sizeof(char));
            snprintf(xml_buf, xml_len, "%s", label);
            xml_child = XMLNewChild(xml_node, "ancestor", xml_buf);
            switch (type)
            {
                case HAPLO_ANCESTOR_DIRECT:
                    snprintf(xml_buf, 9, "%s", "direct"); 
                    break;
                case HAPLO_ANCESTOR_INDIRECT:
                    snprintf(xml_buf, 9, "%s", "indirect"); 
                    break;
                case HAPLO_ANCESTOR_NONE:
                    snprintf(xml_buf, 9, "%s", "none"); 
                    break;
            }
            XMLNewProp(xml_child, "type", xml_buf);
            free(xml_buf);
            break;
    }
}