image_metric.h

Go to the documentation of this file.

#pragma once

#include <cstring>
#include "interop/util/exception.h"
#include "interop/io/format/generic_layout.h"
#include "interop/io/layout/base_metric.h"
#include "interop/model/metric_base/base_cycle_metric.h"
#include "interop/model/metric_base/metric_set.h"

namespace illumina { namespace interop { namespace model { namespace metrics
{
    class image_metric_header : public metric_base::base_cycle_metric::header_type
    {
    public:
        enum
        {
            MAX_CHANNELS = 4
        };
        typedef ::uint16_t ushort_t;
    public:
        image_metric_header(ushort_t channel_count) : m_channel_count(channel_count)
        { }

        ushort_t channelCount() const
        { return m_channel_count; }
        ushort_t channel_count() const
        { return m_channel_count; }
        void channel_count(const size_t channel_count)
        {
            m_channel_count = static_cast<ushort_t>(channel_count);
        }

        static image_metric_header default_header()
        {
            return image_metric_header(MAX_CHANNELS);
        }
        void clear()
        {
            m_channel_count=MAX_CHANNELS;
            metric_base::base_cycle_metric::header_type::clear();
        }

    private:
        ushort_t m_channel_count;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };

    class image_metric : public metric_base::base_cycle_metric
    {
    public:
        enum
        {
            MAX_CHANNELS = image_metric_header::MAX_CHANNELS,
            TYPE = constants::Image,
            LATEST_VERSION = 3
        };
        typedef image_metric_header header_type;
        typedef std::vector<ushort_t> ushort_array_t;
        typedef ::uint16_t *ushort_pointer_t;
    public:
        image_metric() :
                metric_base::base_cycle_metric(0, 0, 0),
                m_min_contrast(MAX_CHANNELS, std::numeric_limits<ushort_t>::max()),
                m_max_contrast(MAX_CHANNELS, std::numeric_limits<ushort_t>::max()),
                m_channel_count(0)
        { }
        image_metric(const header_type& header) :
                metric_base::base_cycle_metric(0, 0, 0),
                m_min_contrast(header.channel_count(), std::numeric_limits<ushort_t>::max()),
                m_max_contrast(header.channel_count(), std::numeric_limits<ushort_t>::max()),
                m_channel_count(0)
        { }

        image_metric(const uint_t lane,
                     const uint_t tile,
                     const uint_t cycle,
                     const ushort_t channel_count,
                     const ushort_array_t &min_contrast,
                     const ushort_array_t &max_contrast) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_min_contrast(min_contrast),
                m_max_contrast(max_contrast),
                m_channel_count(channel_count)
        {
        }

        image_metric(const uint_t lane,
                     const uint_t tile,
                     const uint_t cycle,
                     const ushort_t channel_count,
                     const ushort_pointer_t min_contrast,
                     const ushort_pointer_t max_contrast) :
                metric_base::base_cycle_metric(lane, tile, cycle),
                m_min_contrast(min_contrast, min_contrast + channel_count),
                m_max_contrast(max_contrast, max_contrast + channel_count),
                m_channel_count(channel_count)
        {
        }

    public:
        ushort_t min_contrast(const size_t channel) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(channel, m_min_contrast.size(), "Channel out of bounds");
            return m_min_contrast[channel];
        }

        ushort_t max_contrast(const size_t channel) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(channel, m_max_contrast.size(), "Channel out of bounds");
            return m_max_contrast[channel];
        }

        const ushort_array_t &min_contrast_array() const
        {
            return m_min_contrast;
        }

        const ushort_array_t &max_contrast_array() const
        {
            return m_max_contrast;
        }

        ushort_t channel_count() const
        {
            return m_channel_count;
        }

        bool is_any_channel_blank() const
        {
            for(size_t channel = 0; channel < channel_count(); ++channel)
            {
                if(max_contrast(channel) == 0 && min_contrast(channel) == 0)
                    return true;
            }
            return false;
        }

        void trim(const size_t channel_count)
        {
            m_channel_count = static_cast<ushort_t>(channel_count);
            m_max_contrast.resize(channel_count);
            m_min_contrast.resize(channel_count);
        }
        ushort_t minContrast(size_t channel) const
        {
            INTEROP_ASSERT(channel < m_channel_count);
            return m_min_contrast[channel];
        }

        ushort_t maxContrast(size_t channel) const
        {
            INTEROP_ASSERT(channel < m_channel_count);
            return m_max_contrast[channel];
        }

        const ushort_array_t &minContrast() const
        {
            return m_min_contrast;
        }

        const ushort_array_t &maxContrast() const
        {
            return m_max_contrast;
        }

        ushort_t channelCount() const
        {
            return m_channel_count;
        }

    public:
        static const char *prefix()
        { return "Image"; }

    private:
        ushort_array_t m_min_contrast;
        ushort_array_t m_max_contrast;
        ushort_t m_channel_count;
        template<class MetricType, int Version>
        friend
        struct io::generic_layout;
    };
}}}}