chunk_viz::ChunkVisualizer< T > Class Template Reference

Class for visualizing chunk data in various formats. More...

#include <chunk_visualization.hpp>

Collaboration diagram for chunk_viz::ChunkVisualizer< T >:

Public Member Functions
template<typename U = T>
	ChunkVisualizer (const std::vector< std::vector< U > > &input_data, const std::string &viz_dir="./viz")
	ChunkVisualizer (const std::vector< T > &input_data, const std::string &viz_dir="./viz")
void	export_to_graphviz (const std::string &filename="chunks.dot")
const std::vector< T > &	get_data () const
const std::string &	get_output_dir () const
void	plot_chunk_sizes ()
void	visualize_boundaries ()

Private Member Functions
double	calculate_difference (const T &current, const T &previous) const
std::string	format_value (const T &value) const
void	write_data_file (const std::string &filename, const std::vector< std::pair< size_t, size_t > > &chunk_sizes)

Private Attributes
std::vector< T >	data
std::string	output_dir

Static Private Attributes
static constexpr double	threshold = 1.0

Detailed Description

template<typename T>
class chunk_viz::ChunkVisualizer< T >

Class for visualizing chunk data in various formats.

Template Parameters

T	The data type of the chunks (must be arithmetic)

Definition at line 28 of file chunk_visualization.hpp.

Constructor & Destructor Documentation

ChunkVisualizer() [1/2]

template<typename T >

chunk_viz::ChunkVisualizer< T >::ChunkVisualizer ( const std::vector< T > &  input_data, const std::string &  viz_dir = "./viz"  )

inline

Definition at line 108 of file chunk_visualization.hpp.

        : data(input_data), output_dir(viz_dir) {
        std::filesystem::create_directories(output_dir);
    }

ChunkVisualizer() [2/2]

template<typename T >

template<typename U = T>

chunk_viz::ChunkVisualizer< T >::ChunkVisualizer ( const std::vector< std::vector< U > > &  input_data, const std::string &  viz_dir = "./viz"  )

inline

Definition at line 115 of file chunk_visualization.hpp.

        : data(reinterpret_cast<const std::vector<T>&>(input_data)), output_dir(viz_dir) {
        std::filesystem::create_directories(output_dir);
        static_assert(std::is_same_v<T, std::vector<U>>,
                      "Template parameter must match vector element type");
    }

Member Function Documentation

calculate_difference()

template<typename T >

double chunk_viz::ChunkVisualizer< T >::calculate_difference ( const T &  current, const T &  previous  ) const

inlineprivate

Definition at line 35 of file chunk_visualization.hpp.

                                                                           {
        if constexpr (std::is_arithmetic_v<T>) {
            return std::abs(current - previous);
        } else if constexpr (std::is_same_v<T, std::vector<double>> ||
                             std::is_same_v<T, std::vector<float>> ||
                             std::is_same_v<T, std::vector<int>>) {
            // For vectors, calculate Euclidean distance
            if (current.size() != previous.size()) {
                return std::numeric_limits<double>::max();
            }
            double sum = 0.0;
            for (size_t i = 0; i < current.size(); ++i) {
                double diff = current[i] - previous[i];
                sum += diff * diff;
            }
            return std::sqrt(sum);
        } else {
            throw chunk_processing::VisualizationError(
                "Unsupported type for difference calculation");
        }
    }

export_to_graphviz()

template<typename T >

void chunk_viz::ChunkVisualizer< T >::export_to_graphviz ( const std::string &  filename = "chunks.dot" )

inline

Definition at line 173 of file chunk_visualization.hpp.

                                                                      {
        // Ensure the output directory exists
        std::filesystem::create_directories(output_dir);
 
        // Create full path
        std::string actual_filename;
        if (filename.find('/') != std::string::npos) {
            // If filename contains a path, use it as is
            actual_filename = filename;
        } else {
            // Otherwise, append to output_dir
            actual_filename = output_dir + "/" + filename;
        }
 
        // Create the file
        std::ofstream file(actual_filename);
        if (!file.is_open()) {
            throw chunk_processing::VisualizationError("Failed to create GraphViz file: " +
                                                       actual_filename);
        }
 
        try {
            file << "digraph chunks {\n";
            for (size_t i = 0; i < data.size(); ++i) {
                file << "  chunk" << i << " [label=\"Value: " << format_value(data[i]) << "\"];\n";
                if (i > 0) {
                    file << "  chunk" << (i - 1) << " -> chunk" << i << ";\n";
                }
            }
            file << "}\n";
 
            // Ensure everything is written
            file.flush();
 
            if (file.fail()) {
                throw chunk_processing::VisualizationError("Failed to write to GraphViz file: " +
                                                           actual_filename);
            }
        } catch (const std::exception& e) {
            throw chunk_processing::VisualizationError(
                std::string("Error writing GraphViz file: ") + e.what());
        }
 
        file.close();
 
        // Verify the file was created and has content
        if (!std::filesystem::exists(actual_filename) ||
            std::filesystem::file_size(actual_filename) == 0) {
            throw chunk_processing::VisualizationError("GraphViz file was not created properly: " +
                                                       actual_filename);
        }
    }

Referenced by main().

format_value()

template<typename T >

std::string chunk_viz::ChunkVisualizer< T >::format_value ( const T &  value ) const

inlineprivate

Definition at line 58 of file chunk_visualization.hpp.

                                                 {
        if constexpr (std::is_arithmetic_v<T>) {
            return std::to_string(value);
        } else if constexpr (std::is_same_v<T, std::string>) {
            return value;
        } else if constexpr (std::is_same_v<T, std::vector<double>> ||
                             std::is_same_v<T, std::vector<float>> ||
                             std::is_same_v<T, std::vector<int>>) {
            std::stringstream ss;
            ss << "[";
            for (size_t i = 0; i < value.size(); ++i) {
                ss << value[i];
                if (i < value.size() - 1)
                    ss << ",";
            }
            ss << "]";
            return ss.str();
        } else {
            throw chunk_processing::VisualizationError("Unsupported type for visualization");
        }
    }

get_data()

template<typename T >

const std::vector< T > & chunk_viz::ChunkVisualizer< T >::get_data ( ) const

inline

Definition at line 269 of file chunk_visualization.hpp.

                                         {
        return data;
    }

get_output_dir()

template<typename T >

const std::string & chunk_viz::ChunkVisualizer< T >::get_output_dir ( ) const

inline

Definition at line 272 of file chunk_visualization.hpp.

                                            {
        return output_dir;
    }

plot_chunk_sizes()

template<typename T >

void chunk_viz::ChunkVisualizer< T >::plot_chunk_sizes ( )

inline

Definition at line 123 of file chunk_visualization.hpp.

                            {
        // Calculate chunk sizes
        std::vector<std::pair<size_t, size_t>> chunk_sizes;
        size_t current_size = 1; // Initialize to 1 since we start from first element
 
        // Handle empty data case
        if (data.empty()) {
            throw chunk_processing::ChunkingError("Cannot plot chunk sizes for empty data");
        }
 
        // Handle single element case
        if (data.size() == 1) {
            chunk_sizes.push_back({0, 1});
        } else {
            // Process chunks
            for (size_t i = 1; i < data.size(); ++i) {
                if (calculate_difference(data[i], data[i - 1]) > threshold) {
                    chunk_sizes.push_back({i - current_size, current_size});
                    current_size = 1; // Reset to 1 since we're starting a new chunk
                } else {
                    current_size++;
                }
            }
 
            // Add final chunk
            if (current_size > 0) {
                chunk_sizes.push_back({data.size() - current_size, current_size});
            }
        }
 
        // Write data file
        std::string dat_file = output_dir + "/chunk_sizes.dat";
        write_data_file(dat_file, chunk_sizes);
 
        // Create gnuplot script
        std::string gnu_file = output_dir + "/plot_chunks.gnu";
        std::ofstream gnuplot(gnu_file);
        if (!gnuplot) {
            throw chunk_processing::ChunkingError("Failed to create gnuplot file");
        }
 
        gnuplot << "set title 'Chunk Size Distribution'\n"
                << "set xlabel 'Chunk Index'\n"
                << "set ylabel 'Size'\n"
                << "set style fill solid\n"
                << "plot '" << dat_file << "' using 1:2 with boxes title 'Chunk Sizes'\n";
 
        gnuplot.close();
    }

Referenced by main().

visualize_boundaries()

template<typename T >

void chunk_viz::ChunkVisualizer< T >::visualize_boundaries ( )

inline

Definition at line 226 of file chunk_visualization.hpp.

                                {
        std::ofstream boundary_data(output_dir + "/boundaries.dat");
        if (!boundary_data) {
            throw chunk_processing::VisualizationError("Failed to create boundaries.dat");
        }
 
        // Create gnuplot script for boundary visualization
        std::ofstream gnuplot_script(output_dir + "/plot_boundaries.gnu");
        if (!gnuplot_script) {
            throw chunk_processing::VisualizationError("Failed to create gnuplot script");
        }
 
        // Write data points and mark boundaries
        for (size_t i = 0; i < data.size(); ++i) {
            if constexpr (std::is_arithmetic_v<T>) {
                boundary_data << i << " " << data[i] << " "
                              << (i > 0 && std::abs(data[i] - data[i - 1]) > 1.0 ? "1" : "0")
                              << "\n";
            } else {
                // For vector types, use the first element or size as indicator
                double value = data[i].empty() ? 0.0 : data[i][0];
                boundary_data << i << " " << value << " "
                              << (i > 0 && std::abs(value -
                                                    (data[i - 1].empty() ? 0.0 : data[i - 1][0])) >
                                               1.0
                                      ? "1"
                                      : "0")
                              << "\n";
            }
        }
 
        // Write gnuplot script
        gnuplot_script
            << "set terminal png\n"
            << "set output '" << output_dir << "/boundaries.png'\n"
            << "set title 'Chunk Boundaries'\n"
            << "set xlabel 'Index'\n"
            << "set ylabel 'Value'\n"
            << "plot '" << output_dir << "/boundaries.dat' using 1:2 with lines title 'Data', "
            << "     '" << output_dir
            << "/boundaries.dat' using 1:($3 * $2) with points pt 7 title 'Boundaries'\n";
    }

Referenced by main().

write_data_file()

template<typename T >

void chunk_viz::ChunkVisualizer< T >::write_data_file ( const std::string &  filename, const std::vector< std::pair< size_t, size_t > > &  chunk_sizes  )

inlineprivate

Definition at line 81 of file chunk_visualization.hpp.

                                                                                {
        std::ofstream file(filename);
        if (!file) {
            throw chunk_processing::ChunkingError("Failed to create data file: " + filename);
        }
 
        // Write header
        file << "# Chunk_Index Size\n";
 
        // Write data with explicit flush
        for (size_t i = 0; i < chunk_sizes.size(); ++i) {
            file << i << " " << chunk_sizes[i].second << "\n";
            file.flush(); // Ensure data is written
        }
 
        file.close();
 
        // Verify file was written
        std::ifstream check(filename);
        if (!check || check.peek() == std::ifstream::traits_type::eof()) {
            throw chunk_processing::ChunkingError("Failed to write data to file: " + filename);
        }
    }

Member Data Documentation

data

template<typename T >

std::vector<T> chunk_viz::ChunkVisualizer< T >::data

private

Definition at line 30 of file chunk_visualization.hpp.

output_dir

template<typename T >

std::string chunk_viz::ChunkVisualizer< T >::output_dir

private

Definition at line 31 of file chunk_visualization.hpp.

threshold

template<typename T >

constexpr double chunk_viz::ChunkVisualizer< T >::threshold = 1.0

staticconstexprprivate

Definition at line 32 of file chunk_visualization.hpp.

---

The documentation for this class was generated from the following file:

• chunk_visualization.hpp