flowvis_data.cpp

Go to the documentation of this file.

#include "flowvis_data.h"

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

#include <wx/defs.h>

FlowVisData::FlowVisData()
    : m_swaped(false)
{
    
}

vec3 FlowVisData::GetVelocityAt(const float x, const float y)
{
    assert(-1.0f <= x && x <= 1.0f);
    assert(-1.0f <= y && y <= 1.0f);

    float nx = (x + 1) / 2;
    float ny = 1 - ((y + 1) / 2);

    float lookup_x = (m_grid_max[0] - m_grid_min[0]) * nx + m_grid_min[0];
    float lookup_y = (m_grid_max[1] - m_grid_min[1]) * ny + m_grid_min[1];

    std::vector<float>::iterator upper_x, lower_x, upper_y, lower_y;
    lower_x = upper_x = std::lower_bound(m_grid_x.begin(), m_grid_x.end(), lookup_x);
    lower_y = upper_y = std::lower_bound(m_grid_y.begin(), m_grid_y.end(), lookup_y);
    --lower_x;
    --lower_y;

    int ux = upper_x - m_grid_x.begin();
    int uy = upper_y - m_grid_y.begin();
    int lx = ux - 1;
    int ly = uy - 1;
    
    float l_nx = (lookup_x - *lower_x) / (*upper_x - *lower_x);
    float l_ny = (lookup_y - *lower_y) / (*upper_y - *lower_y);

    vec3 erg = m_time[0].velocity[ly][lx] * (1 - l_nx) * (1 - l_ny)
        + m_time[0].velocity[ly][ux] * nx * (1 - l_ny)
        + m_time[0].velocity[uy][lx] * (1 - l_nx) * l_ny
        + m_time[0].velocity[uy][ux] * l_nx * l_ny;

    return erg;
}

VertexData_T FlowVisData::GetVertexData()
{
    VertexData_T vdata;
    vdata.reserve(m_x * m_y * 2);

    float grid_offset_x = m_grid_min[0];
    float grid_width = m_grid_max[0] - m_grid_min[0];
    float grid_offset_y = m_grid_min[1];
    float grid_height = m_grid_max[1] - m_grid_min[1];

    float grid_val = 0;

    for(int y = 0; y < m_y; y++)
    {
        for(int x = 0; x < m_x; x++)
        {
            grid_val = m_grid[y][x].v[0];
            grid_val = (grid_val - grid_offset_x) / grid_width;
            grid_val = grid_val * 2 - 1;
            vdata.push_back(grid_val);

            grid_val = m_grid[y][x].v[1];
            grid_val = (grid_val - grid_offset_y) / grid_height;
            grid_val = grid_val * -2.0f + 1.0f;
            vdata.push_back(grid_val);
        }
    }

    return vdata;
}

ColorData_T FlowVisData::GetColorData(int time, int dataset)
{
    ColorData_T cdata;
    cdata.reserve(m_x * m_y * 3);

    float value = 0;

    for(int y = 0; y < m_y; y++)
    {
        for(int x = 0; x < m_x; x++)
        {
            value = m_time[time].data[dataset][y][x];
            value = (value - m_data_min[dataset]) / (m_data_max[dataset] - m_data_min[dataset]);
            cdata.push_back(value);
            cdata.push_back(value);
            cdata.push_back(value);
        }
    }

    return cdata;
}

IndexData_T FlowVisData::GetIndexData()
{
    IndexData_T idata;
    idata.reserve((m_x - 1) * (m_y - 1) * 4);

    int lt, rt, lb, rb;

    for(int y = 0; y < m_y - 1; y++)
    {
        for(int x = 0; x < m_x - 1; x++)
        {
            lt = y * m_x + x;
            rt = y * m_x + x + 1;
            rb = (y + 1) * m_x + x + 1;
            lb = (y + 1) * m_x + x;
            idata.push_back(lt);
            idata.push_back(rt);
            idata.push_back(rb);
            idata.push_back(lb);
        }
    }

    return idata;
}

void FlowVisData::LoadFromFile(const char *filename)
{
    LoadGrid(filename);
    std::string basename(filename);
    basename = basename.substr(0, basename.rfind('.'));
    for(int time_index = 0; time_index < m_timestamps; time_index++)
    {
        std::ostringstream data_file_name;
        data_file_name << basename << '.' << std::setfill('0') << std::setw(5) << time_index << ".dat";
        LoadData(data_file_name.str().c_str(), time_index);
    }
    //NormalizeVelocity();
}

void FlowVisData::LoadGrid(const char *filename)
{
    std::ifstream in(filename, std::ios::in | std::ios::binary);
    in.exceptions(std::ios::failbit | std::ios::badbit);

    //identifier at beginning of file should be SN4DB but neednot be stored
    std::string identifier;

    char header_buffer[40];
    in.read(header_buffer, 40);

    std::stringstream header(header_buffer);

    header >> identifier
        >> m_x
        >> m_y
        >> m_z
        >> m_sets
        >> m_timestamps
        >> m_interval;

    //prepare min and max vectors for this file (number of min/max values depends on number of sets)
    m_data_min = std::vector<float>(m_sets, 999999);
    m_data_max = std::vector<float>(m_sets, -999999);

    m_grid_min[0] = m_grid_min[1] = 999999;
    m_grid_max[0] = m_grid_max[1] = -999999;

    m_max_velocity_length = -999999;

    m_grid_cell_min_x = -99999;
    m_grid_cell_min_y = 99999;

    float value;

//TODO: I guess somwhere we should consider BIGENDIAN ... but wtf
//  #ifdef WORDS_BIGENDIAN
//  #else
//  #endif

    bool x_done = false;
    bool y_done = false;

    int dx = 0;
    int dy = 1;

    if(in.good() && m_z == 1 && identifier == "SN4DB")
    {
        m_grid = Grid_T(m_y, std::vector<vec3>(m_x));

        for (int z = 0; z < m_z; z++)
        {
            for (int y = 0; y < m_y; y++)
            {
                y_done = false;
                for (int x = 0; x < m_x; x++)
                {
                    in.read(reinterpret_cast<char*>(&value), sizeof(m_grid[y][x][0]));
                    
                    if(x == 1 && y == 0)
                    {
                        if(m_grid[0][0][0] == value)
                        {
                            m_swaped = true;
                            dx = 1;
                            dy = 0;
                        }
                    }

                    m_grid[y][x][dx] = value;
                    m_grid_min[0] = std::min(m_grid_min[0], value);
                    m_grid_max[0] = std::max(m_grid_max[0], value);
                    
                    in.read(reinterpret_cast<char*>(&value), sizeof(m_grid[y][x][1]));
                    m_grid[y][x][dy] = value;
                    m_grid_min[1] = std::min(m_grid_min[1], value);
                    m_grid_max[1] = std::max(m_grid_max[1], value);
                    
                    in.read(reinterpret_cast<char*>(&value), sizeof(value));

                    if(!y_done)
                    {
                        m_grid_y.push_back(m_grid[y][x][1]);
                        y_done = true;
                    }

                    if(!x_done)
                        m_grid_x.push_back(m_grid[y][x][0]);
                }
                x_done = true;
            }
        }
    }
}

void FlowVisData::LoadData(const char *filename, int time_index)
{
    std::ifstream in(filename, std::ios::in | std::ios::binary);
    in.exceptions(std::ios::failbit | std::ios::badbit);

    float value;

    Time_S current_time;

    current_time.velocity = VelocityVec_T(m_y, std::vector<vec3>(m_x));

    for(int i = 0; i < m_sets; i++)
    {
        current_time.data.push_back(DataVec_T(m_y, std::vector<float>(m_x)));
    }

    int dx = (m_swaped)?(1):(0);
    int dy = (m_swaped)?(0):(1);

    for (int z = 0; z < m_z; z++)
    {
        for (int y = 0; y < m_y; y++)
        {
            for (int x = 0; x < m_x; x++)
            {
                in.read(reinterpret_cast<char*>(&value), 4);
                current_time.velocity[y][x][dx] = value;

                in.read(reinterpret_cast<char*>(&value), 4);
                current_time.velocity[y][x][dy] = value;

                in.read(reinterpret_cast<char*>(&value), 4);
                current_time.velocity[y][x][2] = value;

                m_max_velocity_length = std::max(m_max_velocity_length,
                    current_time.velocity[y][x].length());

                for(int set = 0; set < m_sets; set++)
                {
                    in.read(reinterpret_cast<char*>(&value), 4);
                    current_time.data[set][y][x] = value;
                    m_data_min[set] = std::min(m_data_min[set], value);
                    m_data_max[set] = std::max(m_data_max[set], value);
                }
            }
        }
    }

    m_time.push_back(current_time);
}

void FlowVisData::NormalizeVelocity()
{
    vec3 change(0.5f, 0.5f);
    float max_x = -9999;
    float max_y = -9999;
    float min_x = 9999;
    float min_y = 9999;

    for(TimeVec_T::iterator time_iter = m_time.begin();
        time_iter != m_time.end();
        time_iter ++)
    {
        for(VelocityVec_T::iterator vel_row_iter = time_iter->velocity.begin();
            vel_row_iter != time_iter->velocity.end();
            vel_row_iter ++)
        {
            for(std::vector<vec3>::iterator vel_iter = vel_row_iter->begin();
                vel_iter != vel_row_iter->end();
                vel_iter ++)
            {
                *vel_iter = (*vel_iter / m_max_velocity_length);
                max_x = std::max(max_x, vel_iter->v[0]);
                max_y = std::max(max_y, vel_iter->v[1]);
                min_x = std::min(min_x, vel_iter->v[0]);
                min_y = std::min(min_y, vel_iter->v[1]);
            }
        }
    }
}

void FlowVisData::BuildGridLookup()
{
    
}

---