flowcell_data.h

Go to the documentation of this file.

#pragma once

#include <cstring>
#include "interop/util/exception.h"
#include "interop/util/assert.h"
#include "interop/util/cstdint.h"
#include "interop/model/plot/series.h"
#include "interop/model/plot/axes.h"
#include "interop/model/plot/heatmap_data.h"

namespace illumina { namespace interop { namespace model { namespace plot
{

    class flowcell_data : public heatmap_data
    {
    public:
        flowcell_data() : m_data(0), m_swath_count(0), m_tile_count(0), m_free(false)
        { }

        virtual ~flowcell_data()
        {
            clear();
        }

    public:
        ::uint32_t tile_at(const size_t index)const
        {
            INTEROP_ASSERTMSG(m_data != 0, "length: " << length());

            INTEROP_BOUNDS_CHECK(index, length(), "Tile Index out of bounds");
            return m_data[index];
        }

        ::uint32_t tile_id(const size_t lane_idx, const size_t loc) const INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(lane_idx, lane_count(), "Lane Index out of bounds");
            INTEROP_BOUNDS_CHECK(loc, column_count(), "Location Index out of bounds");
            INTEROP_ASSERT(index_of(lane_idx, loc) < length());
            INTEROP_ASSERT(m_data != 0);
            return m_data[index_of(lane_idx, loc)];
        }

        const plot::axis &saxis() const
        {
            return y_axis();
        }

        const std::string &subtitle() const
        {
            return m_subtitle;
        }

        size_t lane_count() const
        {
            return row_count();
        }

        size_t swath_count() const
        {
            return m_swath_count;
        }

        size_t tile_count() const
        {
            return m_tile_count;
        }

        size_t total_tile_count() const
        {
            return m_tile_count * m_swath_count;
        }
    public:

        void set_data(const size_t lane_idx, const size_t loc, const ::uint32_t tile_id, const float value)
        INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(lane_idx, lane_count(), "Lane Index out of bounds");
            INTEROP_BOUNDS_CHECK(loc, column_count(), "Location Index out of bounds");
            heatmap_data::operator()(lane_idx, loc) = value;
            INTEROP_ASSERT(m_data != 0);
            m_data[index_of(lane_idx, loc)] = tile_id;
        }
        ::uint32_t& tile_id(const size_t lane_idx, const size_t loc) INTEROP_THROW_SPEC((model::index_out_of_bounds_exception))
        {
            INTEROP_BOUNDS_CHECK(lane_idx, lane_count(), "Lane Index out of bounds");
            INTEROP_BOUNDS_CHECK(loc, column_count(), "Location Index out of bounds");
            INTEROP_ASSERT(index_of(lane_idx, loc) < length());
            INTEROP_ASSERT(m_data != 0);
            return m_data[index_of(lane_idx, loc)];
        }
        void set_saxis(const plot::axis &plot_axis)
        {
            set_yaxis(plot_axis);
        }

        void set_label(const std::string &label)
        {
            set_ylabel(label);
        }
        void set_subtitle(const std::string &subtitle)
        {
            m_subtitle = subtitle;
        }

        void set_range(const float vmin, const float vmax)
        {
            set_yrange(vmin, vmax);
        }
        void set_buffer(float *data_buffer,
                        ::uint32_t *id_buffer,
                        const size_t lanes,
                        const size_t swaths,
                        const size_t tiles)  INTEROP_THROW_SPEC((model::invalid_parameter))
        {
            heatmap_data::set_buffer(data_buffer, lanes, swaths * tiles);
            set_buffer(id_buffer, swaths, tiles);
        }

        void resize(const size_t lanes, const size_t swaths, const size_t tiles)
        {
            if (lanes != row_count() && swaths != m_swath_count && tiles != m_tile_count)
            {
                heatmap_data::resize(lanes, swaths * tiles);
                resize(swaths, tiles);
            }
        }

        void clear()
        {
            heatmap_data::clear();
            if (m_free)
            {
                delete[] m_data;
                m_data = 0;
                m_free = false;
            }
            m_swath_count = 0;
            m_tile_count = 0;
        }

    protected:
        void set_buffer(::uint32_t *id_buffer)
        {
            if (m_free) INTEROP_THROW(invalid_parameter, "Cannot use internal buffer map with external buffer");
            if (empty()) INTEROP_THROW(invalid_parameter, "Cannot set external buffer to empty map");
            m_data = id_buffer;
        }

        void set_buffer(::uint32_t *id_buffer,
                        const size_t swaths,
                        const size_t tiles)
        {
            if (m_free) delete[] m_data;
            m_data = id_buffer;
            m_swath_count = swaths;
            m_tile_count = tiles;
            m_free = false;
            std::fill(id_buffer, id_buffer+length(), 0);
        }

        void resize(const size_t swaths,
                    const size_t tiles)
        {
            if (m_free) delete[] m_data;
            m_swath_count = swaths;
            m_tile_count = tiles;
            m_data = new ::uint32_t[heatmap_data::length()];
            std::memset(reinterpret_cast<char *>(m_data), 0, sizeof(::uint32_t) * heatmap_data::length());
            m_free = true;
        }
        friend std::ostream& operator<<(std::ostream& out, const flowcell_data& data)
        {
            out << static_cast<const heatmap_data&>(data);
            out << data.m_subtitle << ",";
            out << data.m_swath_count << ",";
            out << data.m_tile_count << ",";
            for(size_t i=0, n=data.length();i<n;++i)
                out << data.m_data[i] << ",";
            return out;
        }
        friend std::istream& operator>>(std::istream& in, flowcell_data& data)
        {
            in >> static_cast<heatmap_data&>(data);
            std::string tmp;
            std::getline(in, data.m_subtitle, ',');
            std::getline(in, tmp, ',');
            const size_t swath_count = util::lexical_cast<size_t>(tmp);
            std::getline(in, tmp, ',');
            const size_t tile_count = util::lexical_cast<size_t>(tmp);
            data.resize(swath_count, tile_count);
            for(size_t i=0, n=data.length();i<n;++i)
            {
                std::getline(in, tmp, ',');
                data.m_data[i] = util::lexical_cast< ::uint32_t >(tmp);
            }
            return in;
        }

protected:
    ::uint32_t* m_data;
    std::string m_subtitle;
    size_t m_swath_count;
    size_t m_tile_count;
private:
    bool m_free;
};

}}}}