imaging_column.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <iosfwd>
#include <vector>
#include "interop/util/assert.h"
#include "interop/util/length_of.h"
#include "interop/util/string.h"
#include "interop/constants/enums.h"
#include "interop/logic/utils/enums.h"
#include "interop/model/table/table_exceptions.h"


#define INTEROP_IMAGING_COLUMN_TYPES \
        INTEROP_TUPLE7(Lane,                  metric_base::base_metric,           lane,                       Void, UInt, IdType, 0)\
        INTEROP_TUPLE7(Tile,                  metric_base::base_metric,           tile,                       Void, UInt, IdType, 0)\
        INTEROP_TUPLE7(Cycle,                 metric_base::base_cycle_metric,     cycle/*dummy*/,             Void, UInt, IdType, 0)\
        INTEROP_TUPLE7(Read,                  metric_base::base_read_metric,      read/*dummy*/,              Void, UInt, IdType, 0)\
        INTEROP_TUPLE7(CycleWithinRead,       metric_base::base_read_metric,      id/*dummy*/,                Void, UInt, IdType, 0)\
        INTEROP_TUPLE7(DensityKPermm2,        metrics::tile_metric,               cluster_density_k,          Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(DensityPfKPermm2,      metrics::tile_metric,               cluster_density_pf_k,       Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(ClusterCountK,         metrics::tile_metric,               cluster_count_k,            Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(ClusterCountPfK,       metrics::tile_metric,               cluster_count_pf_k,         Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(PercentPassFilter,     metrics::tile_metric,               percent_pf,                 Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(PercentAligned,        metrics::tile_metric,               percent_aligned_at,         Read, Float, ValueType, 1)\
        INTEROP_TUPLE7(LegacyPhasingRate,     metrics::tile_metric,               percent_phasing_at,         Read, Float, ValueType, 3)\
        INTEROP_TUPLE7(LegacyPrephasingRate,  metrics::tile_metric,               percent_prephasing_at,      Read, Float, ValueType, 3)\
        INTEROP_TUPLE7(ErrorRate,             metrics::error_metric,              error_rate,                 Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(PercentGreaterThanQ20, metrics::q_metric,                  percent_over_qscore,        Q20,  Float, ValueType, 2)\
        INTEROP_TUPLE7(PercentGreaterThanQ30, metrics::q_metric,                  percent_over_qscore,        Q30,  Float, ValueType, 2)\
        INTEROP_TUPLE7(P90,                   metrics::extraction_metric,         max_intensity_values,       Void, UShort, ChannelArray, 0)\
        INTEROP_TUPLE7(PercentNoCalls,        metrics::corrected_intensity_metric,percent_nocall,             Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(PercentBase,           metrics::corrected_intensity_metric,percent_bases,              Void, Float, BaseArray, 1)\
        INTEROP_TUPLE7(Fwhm,                  metrics::extraction_metric,         focus_scores,               Void, Float, ChannelArray, 2) \
        INTEROP_TUPLE7(Corrected,             metrics::corrected_intensity_metric,corrected_int_all_array,    Void, UShort, BaseArray, 0)\
        INTEROP_TUPLE7(Called,                metrics::corrected_intensity_metric,corrected_int_called_array, Void, UShort, BaseArray, 0)\
        INTEROP_TUPLE7(SignalToNoise,         metrics::corrected_intensity_metric,signal_to_noise,            Void, Float, ValueType, 2)\
        INTEROP_TUPLE7(PhasingWeight,         metrics::phasing_metric,            phasing_weight,             Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(PrephasingWeight,      metrics::phasing_metric,            prephasing_weight,          Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(PhasingSlope,          metrics::dynamic_phasing_metric,    phasing_slope,              Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(PhasingOffset,         metrics::dynamic_phasing_metric,    phasing_offset,             Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(PrephasingSlope,       metrics::dynamic_phasing_metric,    prephasing_slope,           Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(PrephasingOffset,      metrics::dynamic_phasing_metric,    prephasing_offset,          Void, Float, ValueType, 3)\
        INTEROP_TUPLE7(MinimumContrast,       metrics::image_metric,              min_contrast_array,         Void, UShort, ChannelArray, 0)\
        INTEROP_TUPLE7(MaximumContrast,       metrics::image_metric,              max_contrast_array,         Void, UShort, ChannelArray, 0)\
        INTEROP_TUPLE7(Surface,               metric_base::base_metric,           surface,                    NamingConvention, UInt, IdType, 0)\
        INTEROP_TUPLE7(Swath,                 metric_base::base_metric,           swath,                      NamingConvention, UInt, IdType, 0)\
        INTEROP_TUPLE7(Section,               metric_base::base_metric,           section,                    NamingConvention, UInt, IdType, 0)\
        INTEROP_TUPLE7(TileNumber,            metric_base::base_metric,           number,                     NamingConvention, UInt, IdType, 0)\
        INTEROP_TUPLE7(ClusterCountOccupiedK,  metrics::extended_tile_metric,      cluster_count_occupied_k,   Void, Float, ValueType, 1)\
        INTEROP_TUPLE7(PercentOccupied,        metrics::extended_tile_metric,      percent_occupied,           Void, Float, ValueType, 1)

namespace illumina { namespace interop { namespace model { namespace table
{
#   define INTEROP_TUPLE7(Id, Ignored1, Ignored2, Ignored3, Ignored4, Ignored5, Ignored6) Id##Column,

    enum column_id{ INTEROP_IMAGING_COLUMN_TYPES ImagingColumnCount, UnknownColumnId=INTEROP_UNKNOWN};
#   undef INTEROP_TUPLE7

    class imaging_column
    {
    public:
        typedef std::vector<std::string> string_vector;
    public:
        imaging_column() : m_id(UnknownColumnId), m_offset(0) {}
        imaging_column(const size_t index, const size_t offset) :
                m_id(static_cast<column_id>(index)),
                m_name(to_header(m_id)),
                m_offset(offset)
        {
            INTEROP_ASSERT(index < ImagingColumnCount);
        }
        imaging_column(const size_t index, const size_t offset, const string_vector& sub_columns) :
                m_id(static_cast<column_id>(index)),
                m_name(to_header(m_id)),
                m_offset(offset),
                m_subcolumn_names(sub_columns)
        {
            INTEROP_ASSERT(index < ImagingColumnCount);
        }

    public:
        column_id id()const
        {
            return m_id;
        }
        const std::string& name()const
        {
            return m_name;
        }
        bool has_children()const
        {
            return !m_subcolumn_names.empty();
        }
        size_t offset()const
        {
            return m_offset;
        }
        const string_vector& subcolumns()const
        {
            return m_subcolumn_names;
        }
        std::string full_name(const size_t sub_index)const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            if (has_children())
            {
                INTEROP_BOUNDS_CHECK(sub_index, m_subcolumn_names.size(), "SubColumn index out of bounds");
                return m_name + "_" + m_subcolumn_names[sub_index];
            }
            return m_name;
        }

    public:
        void offset(const size_t off)
        {
            m_offset = off;
        }
        void id(const column_id val)
        {
            m_id = val;
        }
        void parse_header_for_id(const std::string& header)
        {
            id(constants::parse<column_id>(to_name(header)));
        }

    public:
        size_t size()const
        {
            return (has_children() ? m_subcolumn_names.size() : 1);
        }
        size_t column_count()const
        {
            return m_offset + size();
        }

    public:
        static std::string to_header(const column_id id)
        {
            return to_header(constants::to_string(id));
        }
        static std::string to_header(const std::string& name)
        {
            std::string header = name;
            util::replace(header, "Percent", "%");
            util::replace(header, "GreaterThan", ">=");
            util::replace(header, "KPermm2", "(k/mm2)");
            util::replace(header, "K", " (k)");
            util::camel_to(header);
            return header;
        }
        static std::string to_name(const std::string& header)
        {
            std::string name = header;
            util::replace(name, "%", "Percent");
            util::replace(name, ">=", "GreaterThan");
            util::replace(name, "(k/mm2)", "KPermm2");
            util::replace(name, " (k)", "K");
            util::camel_from(name);
            return name;
        }
        static std::string to_name(const model::table::imaging_column& header)
        {
            return to_name(header.name());
        }

    private:
        friend std::istream& operator>>(std::istream& in, imaging_column& column);
        friend std::ostream& operator<<(std::ostream& out, const imaging_column& column);

    private:
        column_id m_id;
        std::string m_name;
        size_t m_offset;
        string_vector m_subcolumn_names;
    };


}}}}