diff --git a/FALCHUAN_VS/CompressMethod.cpp b/FALCHUAN_VS/CompressMethod.cpp new file mode 100644 index 0000000..7cdfb98 --- /dev/null +++ b/FALCHUAN_VS/CompressMethod.cpp @@ -0,0 +1,610 @@ +#include +#include +#include +#include +#include +#include "zfp.h" +#include "omp.h" + + +#pragma comment(lib,"zfp.lib") +/////////////////////////////////Function Declaration///////////////////////// +////////////////////////////////compress_ratio function/////////////////////// +int compress_ratio(const arma::fmat& TraceData, const double bits_per_value, std::vector& buffer, size_t& compressed_size_out) { + + auto compress_start = std::chrono::high_resolution_clock::now(); + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(const_cast(TraceData.memptr()), type, TraceData.n_cols, TraceData.n_rows); + + zfp_stream* zfp = zfp_stream_open(NULL); + zfp_stream_set_rate(zfp, bits_per_value, type, 2, 0); + + zfp_stream_set_execution(zfp, zfp_exec_omp); + zfp_stream_set_omp_threads(zfp, 6); + + size_t bufsize = zfp_stream_maximum_size(zfp, field); + buffer.resize(bufsize); + + bitstream* stream = stream_open(reinterpret_cast(buffer.data()), bufsize); + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + size_t compressed_size = zfp_compress(zfp, field); + if (!compressed_size) { + std::cerr << "Compression failed" << std::endl; + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + return -1; + } + + compressed_size_out = compressed_size; + + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + + auto end_compress = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = end_compress - compress_start; + std::cout << "Compression took " << compress_duration.count() << " seconds" << std::endl; + + return 0; +} + + +////////////////////////////////decompress_ratio function///////////////////// +int decompress_ratio(const std::vector& buffer, size_t cols, size_t rows, const double bits_per_value, arma::fmat& decompressedData) { + auto decompress_start = std::chrono::high_resolution_clock::now(); + + if (buffer.empty()) { + std::cerr << "Decompression failed: buffer empty" << std::endl; + return -1; + } + + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(decompressedData.memptr(), type, cols, rows); + if (!field) { + std::cerr << "Decompression failed: Unable to create field" << std::endl; + return -1; + } + + zfp_stream* zfp = zfp_stream_open(NULL); + if (!zfp) { + std::cerr << "Decompression failed: Cannot open zfp stream" << std::endl; + zfp_field_free(field); + return -1; + } + + zfp_stream_set_rate(zfp, bits_per_value, type, 2, 0); + + const char* dataPtr = reinterpret_cast(buffer.data()); + size_t bufferByteSize = buffer.size(); + + bitstream* stream = stream_open((void*)dataPtr, bufferByteSize); + if (!stream) { + std::cerr << "Decompression failed: Unable to open bitstream" << std::endl; + zfp_stream_close(zfp); + zfp_field_free(field); + return -1; + } + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + if (!zfp_decompress(zfp, field)) { + std::cerr << "Decompression failed" << std::endl; + } + stream_close(stream); + zfp_stream_close(zfp); + zfp_field_free(field); + + auto decompress_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration decompress_duration = decompress_end - decompress_start; + std::cout << "Decompression took " << decompress_duration.count() << " seconds" << std::endl; + + return 0; +} + + + +///////////////////////////////reversible function///////////////////////////// +int compress_reversible(const arma::fmat& TraceData, std::vector& buffer, size_t& compressed_size_out) { + auto compress_start = std::chrono::high_resolution_clock::now(); + + // Initialize ZFP field for 2D data + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(const_cast(TraceData.memptr()), type, TraceData.n_cols, TraceData.n_rows); + + // Initialize ZFP stream + zfp_stream* zfp = zfp_stream_open(NULL); + zfp_stream_set_reversible(zfp); + + // Allocate memory for the compressed stream + size_t bufsize = zfp_stream_maximum_size(zfp, field); + buffer.resize(bufsize); + + // Set up the bitstream + bitstream* stream = stream_open(reinterpret_cast(buffer.data()), bufsize); + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + // Perform compression + size_t compressed_size = zfp_compress(zfp, field); + if (!compressed_size) { + std::cerr << "Compression failed" << std::endl; + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + return -1; + } + + compressed_size_out = compressed_size; + + // Clean up + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + auto end_compress = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = end_compress - compress_start; + std::cout << "Compression took " << compress_duration.count() << " seconds" << std::endl; + return 0; +} + + + + +///////////////////////////////reversible decompress function///////////////////////////// +int decompress_reversible(const std::vector& buffer, size_t cols, size_t rows, arma::fmat& decompressedData) { + auto compress_start = std::chrono::high_resolution_clock::now(); + if (buffer.empty()) { + std::cerr << "Decompression failed: buffer is empty" << std::endl; + return -1; + } + + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(decompressedData.memptr(), type, cols, rows); + if (!field) { + std::cerr << "Decompression failed: unable to create field" << std::endl; + return -1; + } + + zfp_stream* zfp = zfp_stream_open(NULL); + if (!zfp) { + std::cerr << "Decompression failed: cannot open zfp stream" << std::endl; + zfp_field_free(field); + return -1; + } + + zfp_stream_set_reversible(zfp); + + const char* dataPtr = reinterpret_cast(buffer.data()); + size_t bufferByteSize = buffer.size(); + + bitstream* stream = stream_open((void*)dataPtr, bufferByteSize); + if (!stream) { + std::cerr << "Decompression failed: Unable to open bitstream" << std::endl; + zfp_stream_close(zfp); + zfp_field_free(field); + return -1; + } + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + if (!zfp_decompress(zfp, field)) { + std::cerr << "Decompression failed" << std::endl; + } + stream_close(stream); + zfp_stream_close(zfp); + zfp_field_free(field); + auto end_compress = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = end_compress - compress_start; + std::cout << "Compression took " << compress_duration.count() << " seconds" << std::endl; + return 0; +} + + + +/////////////////////////////////Function Declaration///////////////////////// +////////////////////////////////compress_accuracyfunction/////////////////////// +int compress_accuracy(const arma::fmat& TraceData, const double accuracy, std::vector& buffer, size_t& compressed_size_out) { + + auto compress_start = std::chrono::high_resolution_clock::now(); + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(const_cast(TraceData.memptr()), type, TraceData.n_cols, TraceData.n_rows); + + zfp_stream* zfp = zfp_stream_open(NULL); + + zfp_stream_accuracy(zfp); + zfp_stream_set_accuracy(zfp, accuracy); + + zfp_stream_set_execution(zfp, zfp_exec_omp); + zfp_stream_set_omp_threads(zfp, 8); + + + size_t bufsize = zfp_stream_maximum_size(zfp, field); + buffer.resize(bufsize); + + bitstream* stream = stream_open(reinterpret_cast(buffer.data()), bufsize); + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + size_t compressed_size = zfp_compress(zfp, field); + if (!compressed_size) { + std::cerr << "Compression failed" << std::endl; + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + return -1; + } + + compressed_size_out = compressed_size; + + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + + auto end_compress = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = end_compress - compress_start; + std::cout << "Compression took " << compress_duration.count() << " seconds" << std::endl; + + return 0; +} + + +////////////////////////////////decompress_accuracy function///////////////////// +int decompress_accuracy(const std::vector& buffer, size_t cols, size_t rows, const double accuracy, arma::fmat& decompressedData) { + auto decompress_start = std::chrono::high_resolution_clock::now(); + + if (buffer.empty()) { + std::cerr << "Decompression failed: buffer empty" << std::endl; + return -1; + } + + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(decompressedData.memptr(), type, cols, rows); + if (!field) { + std::cerr << "Decompression failed: Unable to create field" << std::endl; + return -1; + } + + zfp_stream* zfp = zfp_stream_open(NULL); + if (!zfp) { + std::cerr << "Decompression failed: Cannot open zfp stream" << std::endl; + zfp_field_free(field); + return -1; + } + zfp_stream_accuracy(zfp); + zfp_stream_set_accuracy(zfp, accuracy); + + + const char* dataPtr = reinterpret_cast(buffer.data()); + size_t bufferByteSize = buffer.size(); + + bitstream* stream = stream_open((void*)dataPtr, bufferByteSize); + if (!stream) { + std::cerr << "Decompression failed: Unable to open bitstream" << std::endl; + zfp_stream_close(zfp); + zfp_field_free(field); + return -1; + } + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + if (!zfp_decompress(zfp, field)) { + std::cerr << "Decompression failed" << std::endl; + } + stream_close(stream); + zfp_stream_close(zfp); + zfp_field_free(field); + + auto decompress_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration decompress_duration = decompress_end - decompress_start; + std::cout << "Decompression took " << decompress_duration.count() << " seconds" << std::endl; + + return 0; +} + + + +/////////////////////////////////Function Declaration///////////////////////// +////////////////////////////////compress_precision function/////////////////////// +int compress_precision(const arma::fmat& TraceData, const double precision, std::vector& buffer, size_t& compressed_size_out) { + + auto compress_start = std::chrono::high_resolution_clock::now(); + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(const_cast(TraceData.memptr()), type, TraceData.n_cols, TraceData.n_rows); + + zfp_stream* zfp = zfp_stream_open(NULL); + + zfp_stream_precision(zfp); + zfp_stream_set_precision(zfp, precision); + + zfp_stream_set_execution(zfp, zfp_exec_omp); + zfp_stream_set_omp_threads(zfp, 8); + + + size_t bufsize = zfp_stream_maximum_size(zfp, field); + buffer.resize(bufsize); + + bitstream* stream = stream_open(reinterpret_cast(buffer.data()), bufsize); + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + size_t compressed_size = zfp_compress(zfp, field); + if (!compressed_size) { + std::cerr << "Compression failed" << std::endl; + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + return -1; + } + + compressed_size_out = compressed_size; + + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + + auto end_compress = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = end_compress - compress_start; + std::cout << "Compression took " << compress_duration.count() << " seconds" << std::endl; + + return 0; +} + + +////////////////////////////////decompress_precision function///////////////////// +int decompress_precision(const std::vector& buffer, size_t cols, size_t rows, const double precision, arma::fmat& decompressedData) { + auto decompress_start = std::chrono::high_resolution_clock::now(); + + if (buffer.empty()) { + std::cerr << "Decompression failed: buffer empty" << std::endl; + return -1; + } + + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(decompressedData.memptr(), type, cols, rows); + if (!field) { + std::cerr << "Decompression failed: Unable to create field" << std::endl; + return -1; + } + + zfp_stream* zfp = zfp_stream_open(NULL); + if (!zfp) { + std::cerr << "Decompression failed: Cannot open zfp stream" << std::endl; + zfp_field_free(field); + return -1; + } + zfp_stream_precision(zfp); + zfp_stream_set_precision(zfp, precision); + + + const char* dataPtr = reinterpret_cast(buffer.data()); + size_t bufferByteSize = buffer.size(); + + bitstream* stream = stream_open((void*)dataPtr, bufferByteSize); + if (!stream) { + std::cerr << "Decompression failed: Unable to open bitstream" << std::endl; + zfp_stream_close(zfp); + zfp_field_free(field); + return -1; + } + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + if (!zfp_decompress(zfp, field)) { + std::cerr << "Decompression failed" << std::endl; + } + stream_close(stream); + zfp_stream_close(zfp); + zfp_field_free(field); + + auto decompress_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration decompress_duration = decompress_end - decompress_start; + std::cout << "Decompression took " << decompress_duration.count() << " seconds" << std::endl; + + return 0; +} + + + + + + + + + + + + + +////////////////////////////// file read////////////////////////////// +int part_read(const std::string& filePath, size_t All_T, size_t Samples, size_t t_start, size_t t_end, arma::fmat& TraceData) { + + auto read_start = std::chrono::high_resolution_clock::now(); + std::cout << "start read data.." << std::endl; + if (t_start > t_end || t_end >= All_T || t_start < 0) { + std::cerr << "Invalid t_start or t_end parameter" << std::endl; + return -1; + } + + std::ifstream file(filePath, std::ios::binary); + if (!file.is_open()) { + std::cerr << "Unable to open file: " << filePath << std::endl; + return -1; + } + + size_t get_rows = t_end - t_start + 1; + size_t data_size = get_rows * Samples * sizeof(float); + + file.seekg(t_start * Samples * sizeof(float), std::ios::beg); + + TraceData.set_size(Samples, get_rows); // 先按列优先存储 + if (!file.read(reinterpret_cast(TraceData.memptr()), data_size)) { + std::cerr << "Failed to read file: " << filePath << std::endl; + file.close(); + return -1; + } + file.close(); + + TraceData = TraceData.t(); // 转置矩阵，使其按行优先存储 + + auto read_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration read_duration = read_end - read_start; + std::cout << "part_read took " << read_duration.count() << " seconds" << std::endl; + + return 0; +} + + +///////////////////////////// Read the data that needs to be decompressed///// +bool readCompressedData(const std::string& filename, std::vector& need_decompress) { + std::ifstream file(filename, std::ios::binary | std::ios::ate); + + if (!file.is_open()) { + std::cerr << "Unable to open file: " << filename << std::endl; + return false; + } + + std::streampos size = file.tellg(); + file.seekg(0, std::ios::beg); + + need_decompress.resize(size); + if (!file.read(need_decompress.data(), size)) { + std::cerr << "Failed to read file: " << filename << std::endl; + file.close(); + return false; + } + file.close(); + + return true; +} + +///////////////////////////////// 主函数 ////////////////////////////////////// + +//int main() { +// const std::string path = "D:\\APP\\GeoEastData\\DATA\\data\\BGP33\\chuan\\Seismics\\PostData-for-training\\Volume.part000"; +// +// ////////////////////////////.part000 文件数据读取并重构矩阵 //////////////////// +// size_t Samples = 2001; +// size_t All_Trace = 210000; +// size_t trace_start = 0; +// size_t trace_end = 209999; +// size_t get_trace = trace_end - trace_start + 1; +// const double bpv = 3.0; +// const double precision = 24; +// const double tolerance = 1e-1; +// arma::fmat TraceData; +// +// // 读取part000文件数据 +// int read_result = part_read(path, All_Trace, Samples, trace_start, trace_end, TraceData); +// +// if (read_result != 0) { +// std::cerr << "Error reading part000 file" << std::endl; +// return read_result; +// } +// +// std::cout << "Origin data at index 2001: " << TraceData(0, 2000) << std::endl; +// +// /////////////////////////////// 压缩 //////////////////////////////////////// +// +// size_t compressed_size_out; +// std::vector buffer; +// +// //int compress = compress_ratio(TraceData, bpv, buffer, compressed_size_out); +// int compress = compress_reversible(TraceData, buffer, compressed_size_out); +// +// +// if (compress != 0) { +// std::cerr << "Compression failed" << std::endl; +// return -1; +// } +// +// std::ofstream compressedFile("Compressed.bin", std::ios::binary); +// if (compressedFile.is_open()) { +// compressedFile.write(reinterpret_cast(buffer.data()), compressed_size_out); +// compressedFile.close(); +// } +// else { +// std::cerr << "Failed to open file for writing." << std::endl; +// } +// +// ///////////////////////////// 压缩率 //////////////////////////////////////// +// +// const std::string path_compressed = "Compressed.bin"; +// std::ifstream file_origin_size(path, std::ios::binary | std::ios::ate); +// if (!file_origin_size.is_open()) { +// std::cerr << "Unable to open file: " << path << std::endl; +// return -1; +// } +// std::streampos origin_size = file_origin_size.tellg(); +// file_origin_size.close(); +// +// std::ifstream file_compress_size(path_compressed, std::ios::binary | std::ios::ate); +// if (!file_compress_size.is_open()) { +// std::cerr << "Unable to open file: " << path_compressed << std::endl; +// return -1; +// } +// std::streampos compressed_size = file_compress_size.tellg(); +// file_compress_size.close(); +// +// if (compressed_size == 0) { +// std::cerr << "Compressed file size is zero." << std::endl; +// return -1; +// } +// double compress_ratio = 1 - (double)compressed_size / origin_size; +// std::cout << "Compress Ratio: " << compress_ratio * 100 << "%" << std::endl; +// +// ////////////////////////////// 解压缩 /////////////////////////////////////// +// +// const std::string path_need_decompress = "Compressed.bin"; +// std::vector Need_decompress; +// if (!readCompressedData(path_need_decompress, Need_decompress)) { +// std::cerr << "Failed to read compressed data" << std::endl; +// return -1; +// } +// +// arma::fmat decompressedData(get_trace, Samples); +// //int decompress = decompress_ratio(Need_decompress, Samples, get_trace, bpv, decompressedData); +// int decompress = decompress_reversible(Need_decompress, Samples, get_trace, decompressedData); +// +// if (decompress != 0) { +// std::cerr << "Decompression failed" << std::endl; +// return -1; +// } +// +// std::cout << "Decompressed data at index 2001: " << decompressedData(0, 2000) << std::endl; +// +// +// auto one_start = std::chrono::high_resolution_clock::now(); +// +// // 将decompressedData转换为一维数组 +// +// // 对解压缩后的矩阵进行转置 +// arma::fmat transposedData = decompressedData.t(); +// // 将转置后的矩阵转换为一维数组（列优先） +// +// +// std::vector oneDimensionalArray(transposedData.memptr(), transposedData.memptr() + transposedData.n_elem); +// +// auto one_end = std::chrono::high_resolution_clock::now(); +// std::chrono::duration compress_duration = one_end - one_start; +// std::cout << "trans_matrix_one took " << compress_duration.count() << " seconds" << std::endl; +// +// +// +// +// +// +// // Output the resulting one-dimensional array to verify +// std::cout << "One Dimensional Array: \n" << oneDimensionalArray[2000] << std::endl; +// +// // std::cout << "start writing data to disk.." << std::endl; +// // +// // std::ofstream outputFile("Decompressed.part000", std::ios::binary); +// // outputFile.write(reinterpret_cast(oneDimensionalArray.data()), oneDimensionalArray.size() * sizeof(float)); +// // outputFile.close(); +// // +// // std::cout << "Data written to disk" << std::endl; +// +// return 0; +//} diff --git a/FALCHUAN_VS/CompressMethod.h b/FALCHUAN_VS/CompressMethod.h new file mode 100644 index 0000000..d427722 --- /dev/null +++ b/FALCHUAN_VS/CompressMethod.h @@ -0,0 +1,34 @@ +#ifndef COMPRESSMETHOD_H +#define COMPRESSMETHOD_H + +#include +#include +#include +#include +#include +#include +#include "zfp.h" +#pragma comment(lib,"zfp.lib") + +int compress_accuracy(const arma::fmat& TraceData, const double accuracy, std::vector& buffer, size_t& compressed_size_out); + +int compress_precision(const arma::fmat& TraceData, const double precision, std::vector& buffer, size_t& compressed_size_out); + +int compress_ratio(const arma::fmat& TraceData, const double bits_per_value, std::vector& buffer, size_t& compressed_size_out); + +int compress_reversible(const arma::fmat& TraceData, std::vector& buffer, size_t& compressed_size_out); + +int decompress_accuracy(const std::vector& buffer, size_t cols, size_t rows, const double accuracy, arma::fmat& decompressedData); + +int decompress_precision(const std::vector& buffer, size_t cols, size_t rows, const double precision, arma::fmat& decompressedData); + +int decompress_ratio(const std::vector& buffer, size_t cols, size_t rows, const double bits_per_value, arma::fmat& decompressedData); + +int decompress_reversible(const std::vector& buffer, size_t cols, size_t rows, arma::fmat& decompressedData); + +int part_read(const std::string& filePath, size_t All_T, size_t Samples, size_t t_start, size_t t_end, arma::fmat& TraceData); + +bool readCompressedData(const std::string& filename, std::vector& need_decompress); + +#endif // DATA_READER_H +#pragma once diff --git a/FALCHUAN_VS/FALCHUAN.cpp b/FALCHUAN_VS/FALCHUAN.cpp new file mode 100644 index 0000000..b69aec8 --- /dev/null +++ b/FALCHUAN_VS/FALCHUAN.cpp @@ -0,0 +1,1066 @@ +#include "FALCHUAN.h" +#include +#include +#include +#include +#include "zfp.h" +#include +#include +#pragma comment(lib,"zfp.lib") + + +/////ѹʵ£bit_per_valueѹʹϵΪѹ=-3.1279171*bit_per_value+99.99380986; +///bit_per_value=-99.99380986+ѹʣ/-3.1279171; + + +//////////////////////////////////////ȫֱ/////////////////////////////// +#include +Q_GLOBAL_STATIC(QString, globalCompressFilePathName) +Q_GLOBAL_STATIC(arma::fmat, globalTraceData) +Q_GLOBAL_STATIC(size_t, globalcompressed_size_out) +Q_GLOBAL_STATIC(size_t, globalfilesize) +Q_GLOBAL_STATIC(size_t, globalget_rows) +Q_GLOBAL_STATIC(size_t, globalSample) + +FALCHUAN::FALCHUAN(QWidget* parent) + : QMainWindow(parent) +{ + + ui.setupUi(this); + + // ʱʾҳΪһҳ + ui.stackedWidget->setCurrentIndex(0); + + //1. + connect(ui.ChooseCompressFile, SIGNAL(clicked()), this, SLOT(on_ChooseCompressFile_CompressFilePath_clicked())); + //2. + connect(ui.ChooseCompressStoreFile, SIGNAL(clicked()), this, SLOT(on_ChooseCompressStoreFile_CompressFileStorePath_clicked())); + //3. + connect(ui.ReadCompressPathButton, SIGNAL(clicked()), this, SLOT(on_ReadCompressPathButton_ReadCompressPathFile_cliked())); + //4. + connect(ui.NextPage, SIGNAL(clicked()), this, SLOT(on_NextPage_page2_clicked())); + + + //5.ռλĬʾı + ui.TraceStart->setPlaceholderText(QString::fromLocal8Bit("˴ĬΪ1ʾһС")); + ui.TraceEnd->setPlaceholderText(QString::fromLocal8Bit("˴Ĭ,Ҳȫѹ")); + + ui.Ratio->setPlaceholderText(QString::fromLocal8Bit("90.6")); + // ĬϽֵ + + ui.DeCompressStartTrace->setPlaceholderText(QString::fromLocal8Bit("ĬΪ1ʾһС"));//ѹʼ + + ui.DeCompressEndTrace->setPlaceholderText(QString::fromLocal8Bit("ĬΪУʾȫѹ"));//ѹ + + //ĬϹѡfrm + ui.FRM->setChecked(true); + + //6. + connect(ui.COMPRESS, SIGNAL(clicked()), this, SLOT(on_COMPRESS_page1_clicked())); + + //7. + connect(ui.BackMain, SIGNAL(clicked()), this, SLOT(on_BackMain_page3_clicked())); + + //8. + connect(ui.BackCompress, SIGNAL(clicked()), this, SLOT(on_BackCompress_page1_clicked())); + + //9. + connect(ui.DECOMPRESS, SIGNAL(clicked()), this, SLOT(on_DECOMPRESS__page4_clicked())); + + //10. + connect(ui.BackfirstMain, SIGNAL(clicked()), this, SLOT(on_BackfirstMain_page3_clicked())); + + //11. + connect(ui.NeedDecompressPath, SIGNAL(clicked()), this, SLOT(on_NeedDecompressPath_NeedDecompressPathFile_clicked())); + + //12. + connect(ui.DecompressStorePath, SIGNAL(clicked()), this, SLOT(on_DecompressStorePath_DecompressStorePathFile_clicked())); + + //13. + connect(ui.StartCompress, SIGNAL(clicked()), this, SLOT(on_StartCompress_CompressBrowser_clicked())); + + //14. + connect(ui.StartDecompress, SIGNAL(clicked()), this, SLOT(on_StartDecompress_DecompressBrowser_clicked())); + + //15. + connect(ui.CMQuit, SIGNAL(clicked()), this, SLOT(on_CMQuit_Quit_clicked())); + + //16. + connect(ui.DEQuit, SIGNAL(clicked()), this, SLOT(on_DEQuit_Quit_clicked())); +} +FALCHUAN::~FALCHUAN() {} + + + + + +////////////////////////1.ѡҪѹļťѡļ//////////////////////// +void FALCHUAN::on_ChooseCompressFile_CompressFilePath_clicked() +{ + QString CompressFilePathName = QFileDialog::getOpenFileName(this, QString::fromLocal8Bit("ѡҪѹļ"), "", QString("Geoeast inner files (*.bin)")); + if (!CompressFilePathName.isEmpty()) + { + *globalCompressFilePathName() = CompressFilePathName; + // ·еķбܼӱ + CompressFilePathName.replace("\\", "\\\\"); + ui.CompressFilePath->setPlainText(CompressFilePathName); + } + else + { + QMessageBox::warning(this, "Invalid Path", QString::fromLocal8Bit("δѡļ·Ч.")); + } +} + + + + + + +////////////////////////2.ѡѹļ·ťѡļ//////////////// +void FALCHUAN::on_ChooseCompressStoreFile_CompressFileStorePath_clicked() +{ + ui.FRM->setChecked(true); + bool isFRM = ui.FRM->isChecked(); + + + QString rate = ui.Ratio->text(); + + size_t get_rows_f = *globalget_rows(); + size_t Samples_f = *globalSample(); + + if (isFRM) { + + + ///ѹĬ86.89%4.2 + double compress_ratio = 90.6; + if (!rate.isEmpty()) { + compress_ratio = rate.toDouble(); + } + ///bit_per_value=-99.99380986+ѹʣ/-3.1279171; + double bpv_temp = (-99.99380986 + compress_ratio) / -3.1279171; + double bpv = std::round(bpv_temp * 10.0) / 10.0; // һλС + // // ڽѡ񱣴·֮ǰȼǷѡѹѹ + // if ((!isFRM && !isFLM)) { + // QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ѡѹ")); + // return; + // } + + + + + + // Ĭļ + QString defaultFileName = "compress"; + if (isFRM) { + defaultFileName += QString(".frm_%1_%2_%3") + .arg(QString::number(bpv * 10, 'f', 0)) + .arg(QString::number(get_rows_f)) + .arg(QString::number(Samples_f)); + } + + + // ȡļ· + QString CompressStorePathName = QFileDialog::getSaveFileName(this, QString::fromLocal8Bit("Please select the file to store your compressed data"), defaultFileName, QString("FRL Files(.*)")); + if (!CompressStorePathName.isEmpty()) + { + // ·еķбܼӱ + CompressStorePathName.replace("\\", "\\\\"); + + ui.CompressFileStorePath->setPlainText(CompressStorePathName); + } + else + { + QMessageBox::warning(this, "Invalid Path", QString::fromLocal8Bit("δѡļ·Ч.")); + } + } + + // if (isFLM) { + // + // /////compress_ratio = 54.64 * tolerance^0.142+8.68(0.001....1.1) + // ////tolerance =3.468e-21 * compress_ratio^11.45(13%-60) + // + // /////compress_ratio = -217.6 * tolerance^(-0.01902 )+ 278.5 (5....60) + // ///tolerance = 3.395e-30 * compress_ratio^16.53 (67% -80) + // + // double compress_ratio = 61.66964613; + // double Tolerance = 1.111105; + // double TLA = 1.111105; + // if (!rate.isEmpty()) { + // compress_ratio = rate.toDouble(); + // if (compress_ratio < 15) { + // compress_ratio = 15; + // } + // if (compress_ratio > 75) { + // compress_ratio = 75; + // } + // if(13setPlainText(CompressStorePathName); + // } + // else + // { + // QMessageBox::warning(this, "Invalid Path", QString::fromLocal8Bit("δѡļ·Ч.")); + // } + // } + + +} + + + + + +////////////////////////3.Ҫѹļ·ťļ///////////////////// +void FALCHUAN::on_ReadCompressPathButton_ReadCompressPathFile_cliked() +{ + arma::fmat TraceData; + if (globalCompressFilePathName->isEmpty()) { + QMessageBox::warning(this, "Invalid Path", QString::fromLocal8Bit("ļ·Чδѡļ.")); + return; + } + std::string CompressFilePathNameStr = globalCompressFilePathName->toStdString(); + + QString allTraceCountStr = ui.AllTrace->text(); + QString samplesPerTraceStr = ui.Sample->text(); + + // All_T Samples ǷΪ + if (allTraceCountStr.isEmpty() || samplesPerTraceStr.isEmpty()) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ļ")); + return; + } + + size_t All_T = allTraceCountStr.toULongLong(); + size_t Samples = samplesPerTraceStr.toULongLong(); + + *globalSample() = Samples; //SamplesΪȫֱ + + // ȡ t_start t_endûĬֵ + size_t t_start = 0; + size_t t_end = All_T - 1; + + QString t_startStr = ui.TraceStart->text(); + QString t_endStr = ui.TraceEnd->text(); + + if (!t_startStr.isEmpty()) { + t_start = t_startStr.toULongLong() - 1; + } + + if (!t_endStr.isEmpty()) { + t_end = t_endStr.toULongLong() - 1; + } + + size_t get_rows = t_end - t_start + 1; + + *globalget_rows() = get_rows; //get_rowsΪȫֱ + + ui.ReadCompressPathFile->setPlainText(QString::fromLocal8Bit("ʼݡ\n ---------------------------------")); + QCoreApplication::processEvents(); // ǿˢUI + + + //////////ȡݲʱдTraceData//////////////////////// + auto read_start = std::chrono::high_resolution_clock::now(); + + if (t_start > t_end || t_end > All_T || t_start < 0) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("зΧѡȡǷȷ")); + } + std::ifstream file(CompressFilePathNameStr, std::ios::binary); + if (!file.is_open()) { + QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ļ")); + } + + size_t data_size = get_rows * Samples * sizeof(float); + file.seekg(0, std::ios::end); + + size_t filesize; + filesize = file.tellg();//ȡļС + + *globalfilesize() = filesize; //filesizeΪȫֱ + + //ʼҪ + file.seekg(t_start * Samples * sizeof(float), std::ios::beg); + + TraceData.set_size(Samples, get_rows); // Ȱȴ洢 + if (!file.read(reinterpret_cast(TraceData.memptr()), data_size)) { + QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ȡļ")); + } + file.close(); + + TraceData = TraceData.t(); // תþʹ䰴ȴ洢 + *globalTraceData() = TraceData; //TraceDataΪȫֱ + + auto read_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration read_duration = read_end - read_start; + + ui.ReadCompressPathFile->append(QString::fromLocal8Bit("ݼɣʱ%1 롣\n--------------------------------- ").arg(read_duration.count())); + + + + // ʾصݣ ReadCompressPathFile QTextBrowser ʾ + QString displayText = QString::fromLocal8Bit("ļСΪ%1 ֽڡ\nѾɡ\n ɡ") + .arg(filesize); + ui.ReadCompressPathFile->append(displayText); +} + + + +//////////////////4.Ӽҳתѹҳ////////////////////////////////// +void FALCHUAN::on_NextPage_page2_clicked() { + QString allTraceCountStr = ui.AllTrace->text(); + QString samplesPerTraceStr = ui.Sample->text(); + + // All_T Samples ǷΪ + if (allTraceCountStr.isEmpty() || samplesPerTraceStr.isEmpty()) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ļл")); + return; + } + + + ui.stackedWidget->setCurrentIndex(2); +} + + +//////////////////6. ҳתҳ////////////////////////////////// +void FALCHUAN::on_COMPRESS_page1_clicked() { + ui.stackedWidget->setCurrentIndex(1); +} + +//////////////////7. Ӽҳתҳ//////////////////////////////// +void FALCHUAN::on_BackMain_page3_clicked() { + ui.stackedWidget->setCurrentIndex(0); +} + +///////////////////8.ѹҳתҳ//////////////////////////// +void FALCHUAN::on_BackCompress_page1_clicked() { + ui.stackedWidget->setCurrentIndex(1); +} + + +///////////////////9.ҳתѹ////////////////////////////////////// +void FALCHUAN::on_DECOMPRESS__page4_clicked() { + ui.stackedWidget->setCurrentIndex(3); +} + +///////////////////10.ӽѹҳתҳ////////////////////////////////// +void FALCHUAN::on_BackfirstMain_page3_clicked() { + ui.stackedWidget->setCurrentIndex(0); +} + +///////////////////11.ѡҪѹļ·////////////////////////////////// +void FALCHUAN::on_NeedDecompressPath_NeedDecompressPathFile_clicked() { + QStringList filters; + filters << "Geoeast inner files (*.frm* *.flm*)" // ƥ .frm* .flmļ + << "All Files (*)"; // ƥļ + + QFileDialog dialog(this); + dialog.setNameFilters(filters); + dialog.setWindowTitle(QString::fromLocal8Bit("ѡҪѹļ")); + dialog.setFileMode(QFileDialog::ExistingFile); + + if (dialog.exec() == QDialog::Accepted) { + QString NeedDecompressPathName = dialog.selectedFiles().first(); + if (!NeedDecompressPathName.isEmpty()) { + // ·еķбܼӱ + NeedDecompressPathName.replace("\\", "\\\\"); + ui.NeedDecompressPathFile->setPlainText(NeedDecompressPathName); + } + } +}; + + +///////////////////12.ѡѹļļ//////////////////////////////// +void FALCHUAN::on_DecompressStorePath_DecompressStorePathFile_clicked() { + // ȡԴļ· + QString sourceFilePath = ui.NeedDecompressPathFile->toPlainText(); + if (sourceFilePath.isEmpty()) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ѡѹԴļ")); + return; + } + + //ȡļ· + QFileInfo fileInfo(sourceFilePath); + //QString baseName = fileInfo.completeBaseName(); // ȡļչ + QString baseName = "Decompressed"; + + // ĬϽѹ·ļ + QString defaultDecompressPath = fileInfo.path() + "/" + baseName + ".bin"; + + QString DecompressStorePathName = QFileDialog::getSaveFileName(this, QString::fromLocal8Bit("Please select the folder where your decompressed files are stored"), defaultDecompressPath, "bin files (*.bin)"); + if (!DecompressStorePathName.isEmpty()) + { + // ·еķбܼӱ + DecompressStorePathName.replace("\\", "\\\\"); + + ui.DecompressStorePathFile->setPlainText(DecompressStorePathName); + } +}; + + +//////////////////////////13.ʼѹť///////////////////////////////////// +void FALCHUAN::on_StartCompress_CompressBrowser_clicked() +{ + try { + //ȡCPU߳ + int threads = omp_get_max_threads(); + + + //QString CompressStorePathName; // Ѿ洢ѹļ· + if (globalTraceData->is_empty()) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("TraceData δʼ")); + return; + } + arma::fmat TraceData; + TraceData = *globalTraceData(); + + // ȡ,תΪstd::string(ѹļ洢ļλ) + std::string CompressStorePathNameStr = ui.CompressFileStorePath->toPlainText().toStdString(); + + if (CompressStorePathNameStr.empty()) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ѡѹļ·")); + return; + } + + + + + // ȡ FRM FLM ѡ״̬ + ui.FRM->setChecked(true); + bool isFRMChecked = ui.FRM->isChecked(); + //bool isFLMChecked = ui.FLM->isChecked(); + + // if (!isFLMChecked and !isFRMChecked ) { + // QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ѡһѹ")); + // return; + // } + + + + if (isFRMChecked) { + // FRM ѹ + + // ѹѹʣѹ + double compress_ratio = 90.6; // ʹĬֵ + + QString R = ui.Ratio->text(); + + if (!R.isEmpty()) { + compress_ratio = R.toDouble(); // ʹûֵ + } + + + /// bit_per_value=-99.99380986+ѹʣ/-3.1279171; + double bpv_temp = (-99.9938 + compress_ratio) / -3.1279; + double bpv = std::round(bpv_temp * 10.0) / 10.0; // һλС + + + + ui.CompressBrowser->setPlainText(QString::fromLocal8Bit("ʼѹ\n ---------------------------------")); + QCoreApplication::processEvents(); // ǿˢUI + + + ////////////////////ʼѹ//////////////////////////////////////// + auto compress_start = std::chrono::high_resolution_clock::now(); + zfp_type type = zfp_type_float; + + // TraceData Ƿѳʼ + if (TraceData.is_empty()) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("TraceData δʼ")); + return; + } + + + zfp_field* field = zfp_field_2d(TraceData.memptr(), type, TraceData.n_cols, TraceData.n_rows); + zfp_stream* zfp = zfp_stream_open(NULL); + zfp_stream_set_rate(zfp, bpv, type, 2, 0); + zfp_stream_set_execution(zfp, zfp_exec_omp); + zfp_stream_set_omp_threads(zfp, threads - 2); + + size_t bufsize = zfp_stream_maximum_size(zfp, field); + + std::vector buffer; // 建 + buffer.resize(bufsize); + + bitstream* stream = stream_open(buffer.data(), bufsize); + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + size_t compressed_size = zfp_compress(zfp, field); + if (!compressed_size) { + QMessageBox::warning(this, "Compression failed", QString::fromLocal8Bit("ѹʧܣԣ")); + return; + } + size_t compressed_size_out; + compressed_size_out = compressed_size; // ѹļС + *globalcompressed_size_out() = compressed_size_out; + + + zfp_field_free(field); + zfp_stream_close(zfp); + stream_close(stream); + + auto end_compress = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = end_compress - compress_start; + /////////////////ѹ//////////////////////////////////////// + + if (*globalfilesize() == 0) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("filesize δʼ")); + return; + } + + size_t filesize = *globalfilesize(); + double Calculate_Rate = 100.0 * (1.0 - (double)compressed_size_out / (double)filesize); + + // ui.CompressBrowser->append(QString::fromLocal8Bit("Total filesizes in origin file is %1 byte \n the file compressed is %2 byte") + // .arg(filesize) + // .arg(compressed_size_out)); + // QCoreApplication::processEvents(); // ǿˢUI + + if (*globalget_rows() == 0) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("get_rows δʼ")); + } + + size_t get_rows = *globalget_rows(); + + double per_trace_byte = (double)compressed_size_out / get_rows; + + ui.CompressBrowser->append(QString::fromLocal8Bit("\nѹʹʱΪ%1 롣\n˴εѹΪ%2 %\nʼѹдļ\n---------------------------------") + .arg(compress_duration.count()) + .arg(Calculate_Rate)); + QCoreApplication::processEvents(); // ǿˢUI + + //////////////ѹдļ////////////////////////////////////// + auto write_start = std::chrono::high_resolution_clock::now(); + std::ofstream file(CompressStorePathNameStr, std::ios::binary); + if (!file.is_open()) { + QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ļ")); + } + else { + file.write(buffer.data(), compressed_size_out); + file.close(); + } + + auto write_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration write_duration = write_end - write_start; + + ui.CompressBrowser->append(QString::fromLocal8Bit("ѹдļɡ\n˴д뻨ʱΪ%1 롣\nѹļСΪ%2 ֽڡ\n---------------------------------\n ɡ") + .arg(write_duration.count()) + .arg(compressed_size_out)); + } + + + + + + + + + // if (isFLMChecked) { + // // FLM ѹ + // + // // ui.CompressBrowser->setPlainText(QString::fromLocal8Bit("㷨ڿС\n --------------------------------- \n ")); + // + // /////compress_ratio = 54.64 * tolerance^0.142+8.68(0.001....1.1) + // ////tolerance =3.468e-21 * compress_ratio^11.45 + // + // /////compress_ratio = -217.6 * tolerance^(-0.01902 )+ 278.5 (5....60) + // ///tolerance = 3.395e-30 * compress_ratio^16.53 + // // ѹѹʣѹ + // QString rate = ui.Ratio->text(); + // double compress_ratio = 61.66964613; + // double Tolerance = 1.111105; + // double TLA = 1.111105; + // if (!rate.isEmpty()) { + // compress_ratio = rate.toDouble(); + // if (compress_ratio < 15) { + // compress_ratio = 15; + // } + // if (compress_ratio > 75) { + // compress_ratio = 75; + // } + // if (13 < compress_ratio < 60) { + // Tolerance = 3.468e-21 * pow(compress_ratio, 11.45); + // TLA = std::round(Tolerance * 1000000.0) / 1000000.0; // λС + // } + // if (60 < compress_ratio < 80) { + // Tolerance = 3.395e-30 * pow(compress_ratio, 16.53); + // TLA = std::round(Tolerance * 1000000.0) / 1000000.0; // λС + // } + // } + // + // + // + // ui.CompressBrowser->setPlainText(QString::fromLocal8Bit("ʼѹ\n ---------------------------------")); + // QCoreApplication::processEvents(); // ǿˢUI + // + // + // ////////////////////ʼѹ//////////////////////////////////////// + // auto compress_start = std::chrono::high_resolution_clock::now(); + // zfp_type type = zfp_type_float; + // + // // TraceData Ƿѳʼ + // if (TraceData.is_empty()) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("TraceData δʼ")); + // return; + // } + // + // + // zfp_field* field = zfp_field_2d(TraceData.memptr(), type, TraceData.n_cols, TraceData.n_rows); + // zfp_stream* zfp = zfp_stream_open(NULL); + // + // + // // Ϊ̶ģʽ + // zfp_stream_set_accuracy(zfp, TLA); + // + // + // zfp_stream_set_execution(zfp, zfp_exec_omp); + // zfp_stream_set_omp_threads(zfp, threads - 2); + // + // size_t bufsize = zfp_stream_maximum_size(zfp, field); + // + // std::vector buffer; // 建 + // buffer.resize(bufsize); + // + // bitstream* stream = stream_open(buffer.data(), bufsize); + // zfp_stream_set_bit_stream(zfp, stream); + // zfp_stream_rewind(zfp); + // + // size_t compressed_size = zfp_compress(zfp, field); + // if (!compressed_size) { + // QMessageBox::warning(this, "Compression failed", QString::fromLocal8Bit("ѹʧܣԣ")); + // return; + // } + // size_t compressed_size_out; + // compressed_size_out = compressed_size; // ѹļС + // *globalcompressed_size_out() = compressed_size_out; + // + // + // zfp_field_free(field); + // zfp_stream_close(zfp); + // stream_close(stream); + // + // auto end_compress = std::chrono::high_resolution_clock::now(); + // std::chrono::duration compress_duration = end_compress - compress_start; + // /////////////////ѹ//////////////////////////////////////// + // + // if (*globalfilesize() == 0) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("filesize δʼ")); + // return; + // } + // + // size_t filesize = *globalfilesize(); + // double Calculate_Rate = 100.0 * (1.0 - (double)compressed_size_out / (double)filesize); + // + // // ui.CompressBrowser->append(QString::fromLocal8Bit("Total filesizes in origin file is %1 byte \n the file compressed is %2 byte") + // // .arg(filesize) + // // .arg(compressed_size_out)); + // // QCoreApplication::processEvents(); // ǿˢUI + // + // if (*globalget_rows() == 0) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("get_rows δʼ")); + // } + // + // size_t get_rows = *globalget_rows(); + // + // double per_trace_byte = (double)compressed_size_out / get_rows; + // + // ui.CompressBrowser->append(QString::fromLocal8Bit("ѹѾɡ\nѹÿֽͬΪ%1 ֽڡ\nѹʹʱΪ%2 롣\n˴εѹΪ%3 %\nʼѹдļ\n---------------------------------") + // .arg(per_trace_byte) + // .arg(compress_duration.count()) + // .arg(Calculate_Rate)); + // QCoreApplication::processEvents(); // ǿˢUI + // + // //////////////ѹдļ////////////////////////////////////// + // auto write_start = std::chrono::high_resolution_clock::now(); + // std::ofstream file(CompressStorePathNameStr, std::ios::binary); + // if (!file.is_open()) { + // QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ļ")); + // } + // else { + // file.write(buffer.data(), compressed_size_out); + // file.close(); + // } + // + // auto write_end = std::chrono::high_resolution_clock::now(); + // std::chrono::duration write_duration = write_end - write_start; + // + // ui.CompressBrowser->append(QString::fromLocal8Bit("ѹдļɡ\n˴д뻨ʱΪ%1 롣\nѹļСΪ%2 ֽڡ\n---------------------------------\n ɡ") + // .arg(write_duration.count()) + // .arg(compressed_size_out)); + // } + + + + + + + } + catch (const std::exception& e) { + QMessageBox::critical(this, "Error", QString::fromLocal8Bit("") + e.what()); + } + catch (...) { + QMessageBox::critical(this, "Error", QString::fromLocal8Bit("δ֪")); + } +} + + + + + + + +/////////////////////////////////////14.ʼѹť/////////////////////// +void FALCHUAN::on_StartDecompress_DecompressBrowser_clicked() { + + + + std::vector Need_decompress; + std::string NeedDecompressPathFileStr = ui.NeedDecompressPathFile->toPlainText().toStdString(); + //ȡѹļַ + std::string DecompressStorePathFileStr = ui.DecompressStorePathFile->toPlainText().toStdString(); + + + + + if (NeedDecompressPathFileStr.empty()) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("ѡҪѹļ")); + + } + + if (DecompressStorePathFileStr.empty()) { + QMessageBox::warning(this, "Input Error", QString::fromLocal8Bit("Please select the unzipped file storage folder first")); + } + + ///////////////ȡѹҪIJ//////////////////////////////////// + QString NeedDecompressPathName = ui.NeedDecompressPathFile->toPlainText(); + // ȡļ + QFileInfo fileInfo(NeedDecompressPathName); + QString fileName = fileInfo.fileName(); // ȡļ׺ + ////////////frm㷨 + // ʹʽȡʶֲּ + QRegularExpression re("([a-zA-Z]+)_(\\d+)_(\\d+)_([0-9]+)"); + QRegularExpressionMatch match = re.match(fileName); + + QString letters = match.captured(1); // "frm" + QString bpvNumber = match.captured(2); // ʲ̶֣λ + //QString torlance = match.captured(2); // ݲ̶֣6λ + QString rows = match.captured(3); // λɱ + QString samples = match.captured(4); // + + // bpvNumberתΪСʽ + double numericValue = bpvNumber.toDouble() / 10.0; // תΪСʽ + + //double torlanceValue = torlance.toDouble() / 1000000.0; // תΪСʽ + + + // rowssamplesתΪsize_t + size_t get_rows_f = rows.toULongLong(); + size_t Samples_f = samples.toULongLong(); + + // ҪѹʼͽûĬֵ + size_t DeCoStartTrace = 0; + size_t DeCoEndTrace = get_rows_f - 1; + + QString DCST = ui.DeCompressStartTrace->text(); + QString DCET = ui.DeCompressEndTrace->text(); + + if (!DCST.isEmpty()) { + DeCoStartTrace = DCST.toULongLong() - 1; // Ҫѹʼ + } + + if (!DCET.isEmpty()) { + DeCoEndTrace = DCET.toULongLong() - 1; // ҪѹĽ + } + + + //////////////ȡҪѹļ////////////////////////////////////// + if (letters == "frm") { + + std::ifstream file(NeedDecompressPathFileStr, std::ios::binary | std::ios::ate); + + if (!file.is_open()) { + QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ļ")); + } + + std::streampos size = file.tellg();//ȡѹļܴС + file.seekg(0, std::ios::beg); + + Need_decompress.resize(size); + if (!file.read(Need_decompress.data(), size)) { + QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ȡļ")); + + } + file.close(); + + ///////////////////////////////ʼѹ//////////////////////////// + ui.DecompressBrowser->setPlainText(QString::fromLocal8Bit("\nʼѹ\n ---------------------------------")); + QCoreApplication::processEvents();//ǿˢUI + + + + // if (*globalget_rows == 0) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("get_rows δʼ")); + // } + // + // if (*globalSample == 0) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("Samples δʼ")); + // } + + //size_t get_trace = *globalget_rows(); + //size_t Samples = *globalSample(); + arma::fmat decompressedData(get_rows_f, Samples_f); + //ѹ + + auto decompress_start = std::chrono::high_resolution_clock::now(); + + + if (Need_decompress.empty()) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("Need_decompressҪѹδʼ")); + } + + zfp_type type = zfp_type_float; + zfp_field* field = zfp_field_2d(decompressedData.memptr(), type, Samples_f, get_rows_f); + + if (!field) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("ڲfieldδʼ")); + } + + zfp_stream* zfp = zfp_stream_open(NULL); + if (!zfp) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("ڲzfpδʼ")); + zfp_field_free(field); + } + + //ѹʱͬ + zfp_stream_set_rate(zfp, numericValue, type, 2, 0); + + const char* dataPtr = reinterpret_cast(Need_decompress.data()); + size_t bufferByteSize = Need_decompress.size(); + + bitstream* stream = stream_open((void*)dataPtr, bufferByteSize); + + if (!stream) { + QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("ڲstreamδʼ")); + zfp_field_free(field); + zfp_stream_close(zfp); + } + + zfp_stream_set_bit_stream(zfp, stream); + zfp_stream_rewind(zfp); + + if (!zfp_decompress(zfp, field)) { + QMessageBox::warning(this, "Decompression failed", QString::fromLocal8Bit("ѹʧܣԣ")); + + } + + stream_close(stream); + zfp_stream_close(zfp); + zfp_field_free(field); + + auto decompress_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration decompress_duration = decompress_end - decompress_start; + + //ѹݣȡضУ + arma::fmat LastDecompressData = decompressedData.rows(DeCoStartTrace, DeCoEndTrace); + + //decompressedDataĴС + size_t decom_filesize = (DeCoEndTrace - DeCoStartTrace + 1) * Samples_f * sizeof(float); + + ui.DecompressBrowser->append(QString::fromLocal8Bit("ĽѹѾɡ\n νѹʱΪ%1 롣\n ڿʼѹд̡\n ---------------------------------") + .arg(decompress_duration.count())); + QCoreApplication::processEvents();//ǿˢUI + + //////д + // decompressedDataתΪһά + auto one_start = std::chrono::high_resolution_clock::now(); + // Խѹľת + arma::fmat transposedData = LastDecompressData.t(); + // תúľתΪһά飨ȣ + + std::vector oneDimensionalArray(transposedData.memptr(), transposedData.memptr() + transposedData.n_elem); + + + std::ofstream outputFile(DecompressStorePathFileStr, std::ios::binary); + outputFile.write(reinterpret_cast(oneDimensionalArray.data()), oneDimensionalArray.size() * sizeof(float)); + outputFile.close(); + + + auto one_end = std::chrono::high_resolution_clock::now(); + std::chrono::duration compress_duration = one_end - one_start; + + ui.DecompressBrowser->append(QString::fromLocal8Bit(" ѹдļɡ\n˴д뻨ʱΪ%1 롣\n --------------------------------- \n ɡ") + .arg(compress_duration.count())); + } + + // if(letters=="flm") { + // // FLM ѹ + // + // std::ifstream file(NeedDecompressPathFileStr, std::ios::binary | std::ios::ate); + // + // if (!file.is_open()) { + // QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ļ")); + // } + // + // std::streampos size = file.tellg();//ȡѹļܴС + // file.seekg(0, std::ios::beg); + // + // Need_decompress.resize(size); + // if (!file.read(Need_decompress.data(), size)) { + // QMessageBox::warning(this, "File Error", QString::fromLocal8Bit("޷ȡļ")); + // + // } + // file.close(); + // + // ///////////////////////////////ʼѹ//////////////////////////// + // ui.DecompressBrowser->setPlainText(QString::fromLocal8Bit("\nʼѹ\nҪѹļСΪ%1 ֽڡ\n ҪѹĵΪ <%2> <%3> һ <%4> \n ---------------------------------") + // .arg(size) + // .arg(DeCoStartTrace + 1) + // .arg(DeCoEndTrace + 1) + // .arg(DeCoEndTrace - DeCoStartTrace + 1)); + // QCoreApplication::processEvents();//ǿˢUI + // + // + // + // // if (*globalget_rows == 0) { + // // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("get_rows δʼ")); + // // } + // // + // // if (*globalSample == 0) { + // // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("Samples δʼ")); + // // } + // + // //size_t get_trace = *globalget_rows(); + // //size_t Samples = *globalSample(); + // arma::fmat decompressedData(get_rows_f, Samples_f); + // //ѹ + // + // auto decompress_start = std::chrono::high_resolution_clock::now(); + // + // + // if (Need_decompress.empty()) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("Need_decompressҪѹδʼ")); + // } + // + // zfp_type type = zfp_type_float; + // zfp_field* field = zfp_field_2d(decompressedData.memptr(), type, Samples_f, get_rows_f); + // + // if (!field) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("ڲfieldδʼ")); + // } + // + // zfp_stream* zfp = zfp_stream_open(NULL); + // if (!zfp) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("ڲzfpδʼ")); + // zfp_field_free(field); + // } + // + // //ѹʱͬ + // // Ϊ̶ģʽ + // zfp_stream_set_accuracy(zfp, torlanceValue); + // + // const char* dataPtr = reinterpret_cast(Need_decompress.data()); + // size_t bufferByteSize = Need_decompress.size(); + // + // bitstream* stream = stream_open((void*)dataPtr, bufferByteSize); + // + // if (!stream) { + // QMessageBox::warning(this, "Data Error", QString::fromLocal8Bit("ڲstreamδʼ")); + // zfp_field_free(field); + // zfp_stream_close(zfp); + // } + // + // zfp_stream_set_bit_stream(zfp, stream); + // zfp_stream_rewind(zfp); + // + // if (!zfp_decompress(zfp, field)) { + // QMessageBox::warning(this, "Decompression failed", QString::fromLocal8Bit("ѹʧܣԣ")); + // + // } + // + // stream_close(stream); + // zfp_stream_close(zfp); + // zfp_field_free(field); + // + // auto decompress_end = std::chrono::high_resolution_clock::now(); + // std::chrono::duration decompress_duration = decompress_end - decompress_start; + // + // //ѹݣȡضУ + // arma::fmat LastDecompressData = decompressedData.rows(DeCoStartTrace, DeCoEndTrace); + // + // //decompressedDataĴС + // size_t decom_filesize = (DeCoEndTrace - DeCoStartTrace + 1) * Samples_f * sizeof(float); + // + // ui.DecompressBrowser->append(QString::fromLocal8Bit("ĽѹѾɡ\n νѹʱΪ%1 롣\n ڿʼѹд̡\n ---------------------------------") + // .arg(decompress_duration.count())); + // QCoreApplication::processEvents();//ǿˢUI + // + // //////д + // // decompressedDataתΪһά + // auto one_start = std::chrono::high_resolution_clock::now(); + // // Խѹľת + // arma::fmat transposedData = LastDecompressData.t(); + // // תúľתΪһά飨ȣ + // + // std::vector oneDimensionalArray(transposedData.memptr(), transposedData.memptr() + transposedData.n_elem); + // + // + // std::ofstream outputFile(DecompressStorePathFileStr, std::ios::binary); + // outputFile.write(reinterpret_cast(oneDimensionalArray.data()), oneDimensionalArray.size() * sizeof(float)); + // outputFile.close(); + // + // + // auto one_end = std::chrono::high_resolution_clock::now(); + // std::chrono::duration compress_duration = one_end - one_start; + // + // ui.DecompressBrowser->append(QString::fromLocal8Bit(" ѹдļɡ\n˴д뻨ʱΪ%1 롣\nѹļܴСΪ %2 ֽڡ\n --------------------------------- \n ɡ") + // .arg(compress_duration.count()) + // .arg(decom_filesize)); + // + // + // } + +} + + + + + +/////////////////////////15.ѹҳ˳///////////////////////// +void FALCHUAN::on_CMQuit_Quit_clicked() +{ + this->close(); +} + +///////////////////////16.ӽѹҳ˳//////////////////////// +void FALCHUAN::on_DEQuit_Quit_clicked() +{ + this->close(); +} \ No newline at end of file diff --git a/FALCHUAN_VS/FALCHUAN.h b/FALCHUAN_VS/FALCHUAN.h new file mode 100644 index 0000000..4e2f11b --- /dev/null +++ b/FALCHUAN_VS/FALCHUAN.h @@ -0,0 +1,69 @@ +#pragma once +#include +#include "ui_FALCHUAN.h" +#include +#include "zfp.h" +class FALCHUAN : public QMainWindow +{ + Q_OBJECT + + +public: + FALCHUAN(QWidget* parent = nullptr); + ~FALCHUAN(); + // arma::fmat TraceData; // ݾ + //static QString CompressFilePathName; //Ҫѹļ· + +public slots: + //void on__(); + //Ͳдconnect(ûɹٲظ) + + //1.ѡҪѹļ· + void on_ChooseCompressFile_CompressFilePath_clicked(); + + //2.ѡѹļ· + void on_ChooseCompressStoreFile_CompressFileStorePath_clicked(); + + //3.Ҫѹļ·ťļ + void on_ReadCompressPathButton_ReadCompressPathFile_cliked(); + + //4.Ӽҳתѹҳ + void on_NextPage_page2_clicked(); + + //6. ҳתҳ + void on_COMPRESS_page1_clicked(); + + //7. Ӽҳתҳ + void on_BackMain_page3_clicked(); + + //8.ѹҳתҳ + void on_BackCompress_page1_clicked(); + + //9.ҳתѹ + void on_DECOMPRESS__page4_clicked(); + + //10.ӽѹҳתҳ + void on_BackfirstMain_page3_clicked(); + + //11.ѡҪѹļ· + void on_NeedDecompressPath_NeedDecompressPathFile_clicked(); + //12.ѡѹļļ + void on_DecompressStorePath_DecompressStorePathFile_clicked(); + + //13.ʼѹť + void on_StartCompress_CompressBrowser_clicked(); + + //14.ʼѹť + void on_StartDecompress_DecompressBrowser_clicked(); + + //15.ѹҳ˳ + void on_CMQuit_Quit_clicked(); + + //16.ӽѹҳ˳ + void on_DEQuit_Quit_clicked(); + +private: + Ui::Seismic ui; + +}; + diff --git a/FALCHUAN_VS/FALCHUAN.qrc b/FALCHUAN_VS/FALCHUAN.qrc new file mode 100644 index 0000000..fef1300 --- /dev/null +++ b/FALCHUAN_VS/FALCHUAN.qrc @@ -0,0 +1,4 @@ + + + +