trafu_data.cpp

Go to the documentation of this file.

#include "trafu_data.h"
#include "trafupoint.h"

#include <algorithm>
#include <fstream>
#include <sstream>

TraFuData::TraFuData(const char *tfd_filename)
{
    if(tfd_filename)
    {
        this->load_file(tfd_filename);
    }else
    {
        Init();
    }
}

void TraFuData::Init()
{
    this->m_mapping_points.clear();
    this->m_mapping_points.push_back(Mapping_point_t(0, 0, 0, 0, 0, TFP_START));
    this->m_mapping_points.push_back(Mapping_point_t(1, 1, 255, 255, 255, TFP_END));
}

Mapping_point_t TraFuData::mapDensity(float density) const
{
    Mapping_point_t calc_point;
    Mapping_point_iterator_const_t first, second;

    second = first = std::upper_bound(this->m_mapping_points.begin(),
        this->m_mapping_points.end(),
        calc_point);

    if(second != this->m_mapping_points.end())
    {
        first--;

        Mapping_point_t range = *second - *first;
        float current = (density - first->m_density) / range.m_density;

        Mapping_point_t step = range * current;

        calc_point = (*first) + range * current;
    }else
    {
        calc_point = this->m_mapping_points.back();
    }

    return calc_point;
}

struct PointChange_s
{
    float density; 
    float opacity; 

    float red;
    float green;
    float blue;

    PointChange_s(float n_density, float n_opacity, float n_red, float n_green, float n_blue)
        : density(n_density)
        , opacity(n_opacity)
        , red(n_red)
        , green(n_green)
        , blue(n_blue)
    {
    }

    friend Mapping_point_t operator *(const PointChange_s &change, const int scalar)
    {
        return Mapping_point_t(change.density * scalar,
            change.opacity * scalar,
            change.red * scalar,
            change.green * scalar,
            change.blue * scalar);
    }
};

void TraFuData::createDensityVectorPart(Mapping_point_vector_t &vec,
                                        int first_element,
                                        int number_of_elements,
                                        const Mapping_point_iterator_const_t &lower,
                                        const Mapping_point_iterator_const_t &upper) const
{
    Mapping_point_t range = *upper - *lower;
    PointChange_s change(range.m_density / number_of_elements,
        range.m_opacity / number_of_elements,
        static_cast<float>(range.m_colour.red) / number_of_elements,
        static_cast<float>(range.m_colour.green) / number_of_elements,
        static_cast<float>(range.m_colour.blue) / number_of_elements);

    vec[first_element] = *lower;
    for(int i = 0; i < number_of_elements; i++)
    {
        vec[first_element + i] = *lower + (change * i);
    }
}

Mapping_point_vector_t TraFuData::createDensityVector(int number_of_elements) const
{
    Mapping_point_vector_t vec(number_of_elements);
    Mapping_point_iterator_const_t first = m_mapping_points.begin();
    Mapping_point_iterator_const_t second = m_mapping_points.begin();
    ++second;

    int free_elements = number_of_elements - 1;
    int current_elements = 0;
    float free_density = 1;
    float density_range = 0;
    int last_element = 0;

    while(second != m_mapping_points.end())
    {
        density_range = (second->m_density - first->m_density);
        current_elements = free_elements * (density_range / free_density);
        createDensityVectorPart(vec, last_element, current_elements, first, second);
        last_element += current_elements;
        free_density -= density_range;
        free_elements -= current_elements;
        first = second++;
    }

    vec[number_of_elements - 1] = *first;

    return vec;
}

void TraFuData::load_file(const char *tfd_filename)
{
    std::ifstream in(tfd_filename, std::ios::in | std::ios::binary);
    in.exceptions(std::ios::failbit | std::ios::badbit);

    int size = 0;
    Mapping_point_t *new_element = new Mapping_point_t();

    this->m_mapping_points.clear();

    try
    {
        in.read((char*)&size, sizeof(int));

        while(1)
        {
            in.read(reinterpret_cast<char*>(new_element), sizeof(Mapping_point_t));
            this->m_mapping_points.push_back(*new_element);
        }
    }catch(...)
    {

    }

    delete new_element;
}

void TraFuData::save_file(const char *tfd_filename)
{
    std::string filename(tfd_filename);
    if(std::string::npos == filename.rfind("."))
    {
        filename.append(std::string(".tf"));
    }

    std::ofstream out(filename.c_str(), std::ios::out | std::ios::binary);
    out.exceptions(std::ios::failbit | std::ios::badbit);

    int size = (int)this->m_mapping_points.size();

    out.write((char*)&size, sizeof(int));

    for(Mapping_point_iterator_t iterPoint = this->m_mapping_points.begin();
        iterPoint != this->m_mapping_points.end();
        iterPoint++)
    {
        out.write(reinterpret_cast<char*>(&(*iterPoint)), sizeof(*iterPoint));
    }
}

---