VTKWriter_point_set.hpp

/*
 * VTKWriter_point_set.hpp
 *
 *  Created on: Feb 6, 2016
 *      Author: i-bird
 */

#ifndef OPENFPM_IO_SRC_VTKWRITER_POINT_SET_HPP_
#define OPENFPM_IO_SRC_VTKWRITER_POINT_SET_HPP_

#include <boost/mpl/pair.hpp>
#include "VTKWriter_grids_util.hpp"

template <typename Vps>
class ele_vps
{
public:

    typedef Vps value_type;

    const Vps & g;

    size_t mark;

    ele_vps(const Vps & g, size_t mark)
    :g(g),mark(mark)
    {}

};

template <typename Vpp>
class ele_vpp
{
public:

    typedef Vpp value_type;

    const Vpp & g;

    size_t mark;

    ele_vpp(const Vpp & vpp, size_t mark)
    :g(vpp),mark(mark)
    {}

};


template<typename ele_v, typename St>
struct prop_out_v
{
    // property output string
    std::string & v_out;

    // vector that we are processing
    const openfpm::vector_std< ele_v > & vv;

    prop_out_v(std::string & v_out, const openfpm::vector_std< ele_v > & vv)
    :v_out(v_out),vv(vv)
    {};

    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::mpl::at<typename ele_v::value_type::value_type::type,boost::mpl::int_<T::value>>::type ptype;

        meta_prop<boost::mpl::int_<T::value> ,ele_v,St, ptype > m(vv,v_out);
    }

    void lastProp()
    {
        // Create point data properties
        v_out += "SCALARS domain float\n";

        // Default lookup table
        v_out += "LOOKUP_TABLE default\n";

        // Produce point data
        for (size_t k = 0 ; k < vv.size() ; k++)
        {
            auto it = vv.get(k).g.getIterator();

            // if there is the next element
            while (it.isNext())
            {
                if (it.get() < vv.get(k).mark)
                    v_out += "1.0\n";
                else
                    v_out += "0.0\n";

                // increment the iterator and counter
                ++it;
            }
        }
    }
};

template <typename pair>
class VTKWriter<pair,VECTOR_POINTS>
{
    openfpm::vector< ele_vps<typename pair::first >> vps;
    openfpm::vector< ele_vpp<typename pair::second>> vpp;

    size_t get_total()
    {
        size_t tot = 0;

        for (size_t i = 0 ; i < vps.size() ; i++)
        {
            tot += vps.get(i).g.size();
        }
        return tot;
    }

    std::string get_vertex_properties_list()
    {
        std::string v_out;

        // write the number of vertex
        v_out += "VERTICES " + std::to_string(get_total()) + " " + std::to_string(get_total() * 2) + "\n";

        // return the vertex properties string
        return v_out;
    }

    std::string get_point_properties_list()
    {
        std::string v_out;

        // write the number of vertex
        v_out += "POINTS " + std::to_string(get_total()) + " float" + "\n";

        // return the vertex properties string
        return v_out;
    }

    std::string get_point_list()
    {
        std::stringstream v_out;


        for (size_t i = 0 ; i < vps.size() ; i++)
        {
            auto it = vps.get(i).g.getIterator();

            // if there is the next element
            while (it.isNext())
            {
                Point<pair::first::value_type::dims,typename pair::first::value_type::coord_type> p;
                p = vps.get(i).g.get(it.get());

                if (pair::first::value_type::dims == 2)
                    v_out << p.toString() << " 0.0" << "\n";
                else
                    v_out << p.toString() << "\n";

                // increment the iterator and counter
                ++it;
            }
        }

        // return the vertex list
        return v_out.str();
    }

    std::string get_vertex_list()
    {
        std::string v_out;

        size_t k = 0;

        for (size_t i = 0 ; i < vps.size() ; i++)
        {
            auto it = vps.get(i).g.getIterator();

            while (it.isNext())
            {
                v_out += "1 " + std::to_string(k) + "\n";

                ++k;
                ++it;
            }
        }
        // return the vertex list
        return v_out;
    }

    std::string get_point_data_header()
    {
        std::string v_out;

        v_out += "POINT_DATA " + std::to_string(get_total()) + "\n";

        return v_out;
    }

public:

    VTKWriter()
    {}

    void add(const typename pair::first & vps, const typename pair::second & vpp,size_t mark)
    {
        ele_vps<typename pair::first> t1(vps,mark);
        ele_vpp<typename pair::second> t2(vpp,mark);

        this->vps.add(t1);
        this->vpp.add(t2);
    }

    template<int prp = -1> bool write(std::string file, std::string f_name = "grids" , file_type ft = file_type::ASCII)
    {
        // Header for the vtk
        std::string vtk_header;
        // Point list of the VTK
        std::string point_list;
        // Vertex list of the VTK
        std::string vertex_list;
        // Graph header
        std::string vtk_binary_or_ascii;
        // vertex properties header
        std::string point_prop_header;
        // edge properties header
        std::string vertex_prop_header;
        // Data point header
        std::string point_data_header;
        // Data point
        std::string point_data;

        // VTK header
        vtk_header = "# vtk DataFile Version 3.0\n"
                     + f_name + "\n";

        // Choose if binary or ASCII
        if (ft == file_type::ASCII)
        {vtk_header += "ASCII\n";}
        else
        {vtk_header += "BINARY\n";}

        // Data type for graph is DATASET POLYDATA
        vtk_header += "DATASET POLYDATA\n";

        // point properties header
        point_prop_header = get_point_properties_list();

        // Get point list
        point_list = get_point_list();

        // vertex properties header
        vertex_prop_header = get_vertex_properties_list();

        // Get vertex list
        vertex_list = get_vertex_list();

        // Get the point data header
        point_data_header = get_point_data_header();

        // For each property in the vertex type produce a point data

        prop_out_v< ele_vpp<typename pair::second>, typename pair::first::value_type::coord_type> pp(point_data, vpp);

        if (prp == -1)
            boost::mpl::for_each< boost::mpl::range_c<int,0, pair::second::value_type::max_prop> >(pp);
        else
            boost::mpl::for_each< boost::mpl::range_c<int,prp, prp> >(pp);

        // Add the last property
        pp.lastProp();


        // write the file
        std::ofstream ofs(file);

        // Check if the file is open
        if (ofs.is_open() == false)
        {std::cerr << "Error cannot create the VTK file: " + file + "\n";}

        ofs << vtk_header << point_prop_header << point_list <<
                vertex_prop_header << vertex_list << point_data_header << point_data;

        // Close the file

        ofs.close();

        // Completed succefully
        return true;
    }
};


#endif /* OPENFPM_IO_SRC_VTKWRITER_POINT_SET_HPP_ */