Classes | |
class | diskio |
class for saving and loading matrices and fields More... | |
Enumerations | |
enum | file_type { auto_detect, raw_ascii, arma_ascii, arma_binary, pgm_binary, ppm_binary } |
file types supported by Armadillo More... | |
Functions | |
template<typename eT > | |
static std::string | diskio::gen_txt_header (const Mat< eT > &x) |
Generate the first line of the header used for saving matrices in text format. Format: "ARMA_MAT_TXT_ABXYZ". A is one of: I (for integral types) or F (for floating point types). B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes. | |
template<typename eT > | |
static std::string | diskio::gen_bin_header (const Mat< eT > &x) |
Generate the first line of the header used for saving matrices in binary format. Format: "ARMA_MAT_BIN_ABXYZ". A is one of: I (for integral types) or F (for floating point types). B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes. | |
static char | diskio::conv_to_hex_char (const u8 x) |
static void | diskio::conv_to_hex (char *out, const u8 x) |
static std::string | diskio::gen_tmp_name (const std::string &x) |
Append a quasi-random string to the given filename. The rand() function is deliberately not used, as rand() has an internal state that changes from call to call. Such states should not be modified in scientific applications, where the results should be reproducable and not affected by saving data. | |
static void | diskio::safe_rename (const std::string &old_name, const std::string &new_name) |
Safely rename a file. Before renaming, test if we can write to the final file. This should prevent: (i) overwriting files that have been write protected, (ii) overwriting directories. | |
template<typename eT > | |
static void | diskio::save_raw_ascii (const Mat< eT > &x, const std::string &name) |
Save a matrix as raw text (no header, human readable). Matrices can be loaded in Matlab and Octave, as long as they don't have complex elements. | |
template<typename eT > | |
static void | diskio::save_arma_ascii (const Mat< eT > &x, const std::string &name) |
Save a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::save_arma_ascii (const Mat< eT > &x, const std::string &name, std::ofstream &f) |
Save a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::save_arma_binary (const Mat< eT > &x, const std::string &name) |
Save a matrix in binary format, with a header that stores the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::save_arma_binary (const Mat< eT > &x, const std::string &name, std::ofstream &f) |
Save a matrix in binary format, with a header that stores the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::save_pgm_binary (const Mat< eT > &x, const std::string &name) |
Save a matrix as a PGM greyscale image. | |
template<typename T > | |
static void | diskio::save_pgm_binary (const Mat< std::complex< T > > &x, const std::string &name) |
Save a matrix as a PGM greyscale image. | |
template<typename eT > | |
static void | diskio::load_raw_ascii (Mat< eT > &x, const std::string &name) |
Load a matrix as raw text (no header, human readable). Can read matrices saved as text in Matlab and Octave. NOTE: this is much slower than reading a file with a header. | |
template<typename eT > | |
static void | diskio::load_arma_ascii (Mat< eT > &x, const std::string &name) |
Load a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::load_arma_ascii (Mat< eT > &x, const std::string &name, std::ifstream &f) |
Load a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::load_arma_binary (Mat< eT > &x, const std::string &name) |
Load a matrix in binary format, with a header that indicates the matrix type as well as its dimensions. | |
template<typename eT > | |
static void | diskio::load_arma_binary (Mat< eT > &x, const std::string &name, std::ifstream &f) |
static void | diskio::pnm_skip_comments (std::fstream &f) |
template<typename eT > | |
static void | diskio::load_pgm_binary (Mat< eT > &x, const std::string &name) |
Load a PGM greyscale image as a matrix. | |
template<typename T > | |
static void | diskio::load_pgm_binary (Mat< std::complex< T > > &x, const std::string &name) |
Load a PGM greyscale image as a matrix. | |
template<typename eT > | |
static void | diskio::load_auto_detect (Mat< eT > &x, const std::string &name) |
Try to load a matrix by automatically determining its type. | |
template<typename T1 > | |
static void | diskio::save_field_arma_binary (const field< T1 > &x, const std::string &name) |
template<typename T1 > | |
static void | diskio::load_field_arma_binary (field< T1 > &x, const std::string &name) |
template<typename T1 > | |
static void | diskio::save_field_ppm_binary (const field< T1 > &x, const std::string &final_name) |
template<typename T1 > | |
static void | diskio::load_field_ppm_binary (field< T1 > &x, const std::string &final_name) |
static void | diskio::save_field_std_string (const field< std::string > &x, const std::string &name) |
static void | diskio::load_field_std_string (field< std::string > &x, const std::string &name) |
template<typename T1 > | |
static void | diskio::load_field_auto_detect (field< T1 > &x, const std::string &name) |
Try to load a field by automatically determining its type. |
enum file_type |
file types supported by Armadillo
auto_detect | Automatically detect the file type (file must be one of the following types). |
raw_ascii | ASCII format (text), without any other information. |
arma_ascii | Armadillo ASCII format (text), with information about matrix type and size. |
arma_binary | Armadillo binary format. |
pgm_binary | Portable Grey Map (greyscale image). |
ppm_binary | Portable Pixel Map (colour image), used by the field class only. |
Definition at line 75 of file forward_proto.hpp.
00076 { 00077 auto_detect, //!< Automatically detect the file type (file must be one of the following types) 00078 raw_ascii, //!< ASCII format (text), without any other information. 00079 arma_ascii, //!< Armadillo ASCII format (text), with information about matrix type and size 00080 arma_binary, //!< Armadillo binary format 00081 pgm_binary, //!< Portable Grey Map (greyscale image) 00082 ppm_binary //!< Portable Pixel Map (colour image), used by the field class only 00083 };
std::string diskio::gen_txt_header | ( | const Mat< eT > & | x | ) | [inline, static, inherited] |
Generate the first line of the header used for saving matrices in text format. Format: "ARMA_MAT_TXT_ABXYZ". A is one of: I (for integral types) or F (for floating point types). B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes.
Definition at line 28 of file diskio_meat.hpp.
Referenced by load_arma_ascii(), and save_arma_ascii().
00029 { 00030 arma_type_check<diskio::is_supported_type<eT>::value == false>::apply(); 00031 00032 if(is_u8<eT>::value == true) 00033 { 00034 return std::string("ARMA_MAT_TXT_IU001"); 00035 } 00036 else 00037 if(is_s8<eT>::value == true) 00038 { 00039 return std::string("ARMA_MAT_TXT_IS001"); 00040 } 00041 else 00042 if(is_u16<eT>::value == true) 00043 { 00044 return std::string("ARMA_MAT_TXT_IU002"); 00045 } 00046 else 00047 if(is_s16<eT>::value == true) 00048 { 00049 return std::string("ARMA_MAT_TXT_IS002"); 00050 } 00051 else 00052 if(is_u32<eT>::value == true) 00053 { 00054 return std::string("ARMA_MAT_TXT_IU004"); 00055 } 00056 else 00057 if(is_s32<eT>::value == true) 00058 { 00059 return std::string("ARMA_MAT_TXT_IS004"); 00060 } 00061 else 00062 if(is_float<eT>::value == true) 00063 { 00064 return std::string("ARMA_MAT_TXT_FN004"); 00065 } 00066 else 00067 if(is_double<eT>::value == true) 00068 { 00069 return std::string("ARMA_MAT_TXT_FN008"); 00070 } 00071 else 00072 if(is_complex_float<eT>::value == true) 00073 { 00074 return std::string("ARMA_MAT_TXT_FC008"); 00075 } 00076 else 00077 if(is_complex_double<eT>::value == true) 00078 { 00079 return std::string("ARMA_MAT_TXT_FC016"); 00080 } 00081 else 00082 { 00083 return std::string(); 00084 } 00085 00086 }
std::string diskio::gen_bin_header | ( | const Mat< eT > & | x | ) | [inline, static, inherited] |
Generate the first line of the header used for saving matrices in binary format. Format: "ARMA_MAT_BIN_ABXYZ". A is one of: I (for integral types) or F (for floating point types). B is one of: U (for unsigned types), S (for signed types), N (for not appliable) or C (for complex types). XYZ specifies the width of each element in terms of bytes, e.g. "008" indicates eight bytes.
Definition at line 98 of file diskio_meat.hpp.
Referenced by load_arma_binary(), and save_arma_binary().
00099 { 00100 arma_type_check<diskio::is_supported_type<eT>::value == false>::apply(); 00101 00102 if(is_u8<eT>::value == true) 00103 { 00104 return std::string("ARMA_MAT_BIN_IU001"); 00105 } 00106 else 00107 if(is_s8<eT>::value == true) 00108 { 00109 return std::string("ARMA_MAT_BIN_IS001"); 00110 } 00111 else 00112 if(is_u16<eT>::value == true) 00113 { 00114 return std::string("ARMA_MAT_BIN_IU002"); 00115 } 00116 else 00117 if(is_s16<eT>::value == true) 00118 { 00119 return std::string("ARMA_MAT_BIN_IS002"); 00120 } 00121 else 00122 if(is_u32<eT>::value == true) 00123 { 00124 return std::string("ARMA_MAT_BIN_IU004"); 00125 } 00126 else 00127 if(is_s32<eT>::value == true) 00128 { 00129 return std::string("ARMA_MAT_BIN_IS004"); 00130 } 00131 if(is_float<eT>::value == true) 00132 { 00133 return std::string("ARMA_MAT_BIN_FN004"); 00134 } 00135 else 00136 if(is_double<eT>::value == true) 00137 { 00138 return std::string("ARMA_MAT_BIN_FN008"); 00139 } 00140 else 00141 if(is_complex_float<eT>::value == true) 00142 { 00143 return std::string("ARMA_MAT_BIN_FC008"); 00144 } 00145 else 00146 if(is_complex_double<eT>::value == true) 00147 { 00148 return std::string("ARMA_MAT_BIN_FC016"); 00149 } 00150 else 00151 { 00152 return std::string(); 00153 } 00154 00155 }
char diskio::conv_to_hex_char | ( | const u8 | x | ) | [inline, static, inherited] |
Definition at line 161 of file diskio_meat.hpp.
Referenced by conv_to_hex().
00162 { 00163 char out; 00164 switch(x) 00165 { 00166 case 0: out = '0'; break; 00167 case 1: out = '1'; break; 00168 case 2: out = '2'; break; 00169 case 3: out = '3'; break; 00170 case 4: out = '4'; break; 00171 case 5: out = '5'; break; 00172 case 6: out = '6'; break; 00173 case 7: out = '7'; break; 00174 case 8: out = '8'; break; 00175 case 9: out = '9'; break; 00176 case 10: out = 'a'; break; 00177 case 11: out = 'b'; break; 00178 case 12: out = 'c'; break; 00179 case 13: out = 'd'; break; 00180 case 14: out = 'e'; break; 00181 case 15: out = 'f'; break; 00182 default: out = '-'; break; 00183 } 00184 00185 return out; 00186 }
void diskio::conv_to_hex | ( | char * | out, | |
const u8 | x | |||
) | [inline, static, inherited] |
Definition at line 192 of file diskio_meat.hpp.
References conv_to_hex_char().
Referenced by gen_tmp_name().
00193 { 00194 const u8 a = x / 16; 00195 const u8 b = x - 16*a; 00196 00197 out[0] = conv_to_hex_char(a); 00198 out[1] = conv_to_hex_char(b); 00199 }
std::string diskio::gen_tmp_name | ( | const std::string & | x | ) | [inline, static, inherited] |
Append a quasi-random string to the given filename. The rand() function is deliberately not used, as rand() has an internal state that changes from call to call. Such states should not be modified in scientific applications, where the results should be reproducable and not affected by saving data.
Definition at line 212 of file diskio_meat.hpp.
References conv_to_hex(), and sum().
Referenced by save_arma_ascii(), save_arma_binary(), save_field_arma_binary(), save_field_ppm_binary(), save_field_std_string(), save_pgm_binary(), and save_raw_ascii().
00213 { 00214 const std::string* ptr_x = &x; 00215 const u8* ptr_ptr_x = reinterpret_cast<const u8*>(&ptr_x); 00216 00217 const char* extra = ".tmp_"; 00218 const u32 extra_size = 5; 00219 00220 const u32 tmp_size = 2*sizeof(u8*) + 2*2; 00221 char tmp[tmp_size]; 00222 00223 u32 char_count = 0; 00224 00225 for(u32 i=0; i<sizeof(u8*); ++i) 00226 { 00227 conv_to_hex(&tmp[char_count], ptr_ptr_x[i]); 00228 char_count += 2; 00229 } 00230 00231 const u32 x_size = x.size(); 00232 u8 sum = 0; 00233 00234 for(u32 i=0; i<x_size; ++i) 00235 { 00236 sum += u8(x[i]); 00237 } 00238 00239 conv_to_hex(&tmp[char_count], sum); 00240 char_count += 2; 00241 00242 conv_to_hex(&tmp[char_count], u8(x_size)); 00243 00244 00245 std::string out; 00246 out.resize(x_size + extra_size + tmp_size); 00247 00248 00249 for(u32 i=0; i<x_size; ++i) 00250 { 00251 out[i] = x[i]; 00252 } 00253 00254 for(u32 i=0; i<extra_size; ++i) 00255 { 00256 out[x_size + i] = extra[i]; 00257 } 00258 00259 for(u32 i=0; i<tmp_size; ++i) 00260 { 00261 out[x_size + extra_size + i] = tmp[i]; 00262 } 00263 00264 return out; 00265 }
void diskio::safe_rename | ( | const std::string & | old_name, | |
const std::string & | new_name | |||
) | [inline, static, inherited] |
Safely rename a file. Before renaming, test if we can write to the final file. This should prevent: (i) overwriting files that have been write protected, (ii) overwriting directories.
Definition at line 276 of file diskio_meat.hpp.
References arma_warn().
Referenced by save_arma_ascii(), save_arma_binary(), save_field_arma_binary(), save_field_ppm_binary(), save_field_std_string(), save_pgm_binary(), and save_raw_ascii().
00277 { 00278 std::fstream f(new_name.c_str(), std::fstream::out | std::fstream::app); 00279 f.put(' '); 00280 00281 const bool writing_problem = (f.good() == false); 00282 f.close(); 00283 00284 arma_warn( writing_problem, "trouble writing ", new_name ); 00285 00286 if(writing_problem == false) 00287 { 00288 std::remove(new_name.c_str()); 00289 00290 const int mv_result = std::rename(old_name.c_str(), new_name.c_str()); 00291 arma_warn( (mv_result != 0), "trouble writing ", new_name ); 00292 } 00293 00294 }
void diskio::save_raw_ascii | ( | const Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Save a matrix as raw text (no header, human readable). Matrices can be loaded in Matlab and Octave, as long as they don't have complex elements.
Definition at line 303 of file diskio_meat.hpp.
References arma_print(), arma_warn(), Mat< eT >::at(), Mat< eT >::col(), gen_tmp_name(), Mat< eT >::n_cols, Mat< eT >::n_rows, Mat< eT >::row(), and safe_rename().
Referenced by Mat< eT >::save().
00304 { 00305 arma_extra_debug_sigprint(); 00306 00307 const std::string tmp_name = diskio::gen_tmp_name(final_name); 00308 00309 std::fstream f(tmp_name.c_str(), std::fstream::out); 00310 00311 if(f.is_open() == false) 00312 { 00313 arma_print("unable to write ", tmp_name); 00314 } 00315 else 00316 { 00317 u32 cell_width; 00318 00319 // TODO: need sane values for complex numbers 00320 00321 if( (is_float<eT>::value == true) || (is_double<eT>::value == true) ) 00322 { 00323 f.setf(ios::scientific); 00324 f.precision(8); 00325 cell_width = 16; 00326 } 00327 00328 for(u32 row=0; row < x.n_rows; ++row) 00329 { 00330 for(u32 col=0; col < x.n_cols; ++col) 00331 { 00332 f.put(' '); 00333 00334 if( (is_float<eT>::value == true) || (is_double<eT>::value == true) ) 00335 { 00336 f.width(cell_width); 00337 } 00338 00339 f << x.at(row,col); 00340 } 00341 00342 f.put('\n'); 00343 } 00344 00345 const bool writing_problem = (f.good() == false); 00346 00347 arma_warn(writing_problem, "trouble writing ", tmp_name ); 00348 00349 f.flush(); 00350 f.close(); 00351 00352 if(writing_problem == false) 00353 { 00354 diskio::safe_rename(tmp_name, final_name); 00355 } 00356 } 00357 00358 }
void diskio::save_arma_ascii | ( | const Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Save a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions.
Definition at line 367 of file diskio_meat.hpp.
References arma_warn(), gen_tmp_name(), and safe_rename().
Referenced by Mat< eT >::save().
00368 { 00369 arma_extra_debug_sigprint(); 00370 00371 const std::string tmp_name = diskio::gen_tmp_name(final_name); 00372 00373 std::ofstream f(tmp_name.c_str()); 00374 00375 diskio::save_arma_ascii(x, tmp_name, f); 00376 00377 const bool writing_problem = (f.good() == false); 00378 00379 f.flush(); 00380 f.close(); 00381 00382 arma_warn( writing_problem, "trouble writing ", tmp_name ); 00383 00384 if(writing_problem == false) 00385 { 00386 diskio::safe_rename(tmp_name, final_name); 00387 } 00388 }
void diskio::save_arma_ascii | ( | const Mat< eT > & | x, | |
const std::string & | name, | |||
std::ofstream & | f | |||
) | [inline, static, inherited] |
Save a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions.
Definition at line 397 of file diskio_meat.hpp.
References Mat< eT >::at(), Mat< eT >::col(), gen_txt_header(), Mat< eT >::n_cols, Mat< eT >::n_rows, and Mat< eT >::row().
00398 { 00399 arma_extra_debug_sigprint(); 00400 00401 if(f.is_open() == false) 00402 { 00403 arma_debug_print("unable to write ", name); 00404 } 00405 else 00406 { 00407 const ios::fmtflags orig_flags = f.flags(); 00408 00409 f << diskio::gen_txt_header(x) << '\n'; 00410 f << x.n_rows << ' ' << x.n_cols << '\n'; 00411 00412 u32 cell_width; 00413 00414 // TODO: need sane values for complex numbers 00415 00416 if( (is_float<eT>::value == true) || (is_double<eT>::value == true) ) 00417 { 00418 f.setf(ios::scientific); 00419 f.precision(8); 00420 cell_width = 16; 00421 } 00422 00423 for(u32 row=0; row < x.n_rows; ++row) 00424 { 00425 for(u32 col=0; col < x.n_cols; ++col) 00426 { 00427 f.put(' '); 00428 00429 if( (is_float<eT>::value == true) || (is_double<eT>::value == true) ) 00430 { 00431 f.width(cell_width); 00432 } 00433 00434 f << x.at(row,col); 00435 } 00436 00437 f.put('\n'); 00438 } 00439 00440 f.flags(orig_flags); 00441 } 00442 }
void diskio::save_arma_binary | ( | const Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Save a matrix in binary format, with a header that stores the matrix type as well as its dimensions.
Definition at line 451 of file diskio_meat.hpp.
References arma_warn(), gen_tmp_name(), and safe_rename().
Referenced by Mat< eT >::save(), and save_field_arma_binary().
00452 { 00453 arma_extra_debug_sigprint(); 00454 00455 const std::string tmp_name = diskio::gen_tmp_name(final_name); 00456 00457 std::ofstream f(tmp_name.c_str(), std::fstream::binary); 00458 00459 diskio::save_arma_binary(x, tmp_name, f); 00460 00461 const bool writing_problem = (f.good() == false); 00462 00463 f.flush(); 00464 f.close(); 00465 00466 arma_warn( writing_problem, "trouble writing ", tmp_name ); 00467 00468 if(writing_problem == false) 00469 { 00470 diskio::safe_rename(tmp_name, final_name); 00471 } 00472 }
void diskio::save_arma_binary | ( | const Mat< eT > & | x, | |
const std::string & | name, | |||
std::ofstream & | f | |||
) | [inline, static, inherited] |
Save a matrix in binary format, with a header that stores the matrix type as well as its dimensions.
Definition at line 481 of file diskio_meat.hpp.
References arma_print(), gen_bin_header(), Mat< eT >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.
00482 { 00483 arma_extra_debug_sigprint(); 00484 00485 if(f.is_open() == false) 00486 { 00487 arma_print("unable to write ", name); 00488 } 00489 else 00490 { 00491 f << diskio::gen_bin_header(x) << '\n'; 00492 f << x.n_rows << ' ' << x.n_cols << '\n'; 00493 00494 f.write(reinterpret_cast<const char*>(x.mem), x.n_elem*sizeof(eT)); 00495 } 00496 00497 }
void diskio::save_pgm_binary | ( | const Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Save a matrix as a PGM greyscale image.
Definition at line 509 of file diskio_meat.hpp.
References arma_print(), arma_warn(), Mat< eT >::col(), gen_tmp_name(), podarray< T1 >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, Mat< eT >::n_rows, Mat< eT >::row(), and safe_rename().
Referenced by Mat< eT >::save(), and save_pgm_binary().
00510 { 00511 arma_extra_debug_sigprint(); 00512 00513 const std::string tmp_name = diskio::gen_tmp_name(final_name); 00514 00515 std::fstream f(tmp_name.c_str(), std::fstream::out | std::fstream::binary); 00516 00517 if(f.is_open() == false) 00518 { 00519 arma_print("unable to write ", tmp_name); 00520 } 00521 else 00522 { 00523 f << "P5" << '\n'; 00524 f << x.n_cols << ' ' << x.n_rows << '\n'; 00525 f << 255 << '\n'; 00526 00527 const u32 n_elem = x.n_rows * x.n_cols; 00528 podarray<u8> tmp(n_elem); 00529 00530 u32 i = 0; 00531 00532 for(u32 row=0; row < x.n_rows; ++row) 00533 { 00534 for(u32 col=0; col < x.n_cols; ++col) 00535 { 00536 tmp[i] = u8( x(row,col) ); // TODO: add round() ? 00537 ++i; 00538 } 00539 } 00540 00541 f.write(reinterpret_cast<const char*>(tmp.mem), n_elem); 00542 00543 const bool writing_problem = (f.good() == false); 00544 00545 arma_warn(writing_problem, "trouble writing ", tmp_name ); 00546 00547 f.flush(); 00548 f.close(); 00549 00550 if(writing_problem == false) 00551 { 00552 diskio::safe_rename(tmp_name, final_name); 00553 } 00554 } 00555 00556 }
void diskio::save_pgm_binary | ( | const Mat< std::complex< T > > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Save a matrix as a PGM greyscale image.
Definition at line 564 of file diskio_meat.hpp.
References save_pgm_binary().
00565 { 00566 arma_extra_debug_sigprint(); 00567 00568 const uchar_mat tmp = conv_to<uchar_mat>::from(x); 00569 diskio::save_pgm_binary(tmp,name); 00570 }
void diskio::load_raw_ascii | ( | Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Load a matrix as raw text (no header, human readable). Can read matrices saved as text in Matlab and Octave. NOTE: this is much slower than reading a file with a header.
Definition at line 580 of file diskio_meat.hpp.
References arma_print(), Mat< eT >::at(), Mat< eT >::col(), Mat< eT >::n_cols, Mat< eT >::n_rows, Mat< eT >::reset(), Mat< eT >::row(), and Mat< eT >::set_size().
Referenced by Mat< eT >::load(), and load_auto_detect().
00581 { 00582 arma_extra_debug_sigprint(); 00583 00584 std::fstream f; 00585 f.open(name.c_str(), std::fstream::in); 00586 00587 bool load_okay = true; 00588 00589 if(f.is_open() == false) 00590 { 00591 load_okay = false; 00592 arma_extra_debug_print("unable to read ", name); 00593 } 00594 else 00595 { 00596 //std::fstream::pos_type start = f.tellg(); 00597 00598 // 00599 // work out the size 00600 00601 00602 u32 f_n_rows = 0; 00603 u32 f_n_cols = 0; 00604 00605 bool f_n_cols_found = false; 00606 00607 std::string line_string; 00608 std::string token; 00609 00610 while( (f.good() == true) && (load_okay == true) ) 00611 { 00612 std::getline(f, line_string); 00613 if(line_string.size() == 0) 00614 break; 00615 00616 std::stringstream line_stream(line_string); 00617 00618 u32 line_n_cols = 0; 00619 while (line_stream >> token) 00620 line_n_cols++; 00621 00622 if(f_n_cols_found == false) 00623 { 00624 f_n_cols = line_n_cols; 00625 f_n_cols_found = true; 00626 } 00627 else 00628 { 00629 if(line_n_cols != f_n_cols) 00630 { 00631 arma_print("inconsistent number of columns in ", name ); 00632 load_okay = false; 00633 } 00634 } 00635 00636 ++f_n_rows; 00637 } 00638 00639 if(load_okay == true) 00640 { 00641 f.clear(); 00642 f.seekg(0, ios::beg); 00643 //f.seekg(start); 00644 00645 x.set_size(f_n_rows, f_n_cols); 00646 00647 eT val; 00648 00649 for(u32 row=0; row < x.n_rows; ++row) 00650 { 00651 for(u32 col=0; col < x.n_cols; ++col) 00652 { 00653 // f >> token; 00654 // x.at(row,col) = eT( strtod(token.c_str(), 0) ); 00655 00656 f >> val; 00657 x.at(row,col) = val; 00658 } 00659 } 00660 } 00661 00662 if(f.good() == false) 00663 { 00664 arma_print("trouble reading ", name ); 00665 load_okay = false; 00666 } 00667 00668 f.close(); 00669 } 00670 00671 00672 if(load_okay == false) 00673 { 00674 x.reset(); 00675 } 00676 00677 }
void diskio::load_arma_ascii | ( | Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Load a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions.
Definition at line 686 of file diskio_meat.hpp.
Referenced by Mat< eT >::load(), and load_auto_detect().
00687 { 00688 arma_extra_debug_sigprint(); 00689 00690 std::ifstream f(name.c_str()); 00691 diskio::load_arma_ascii(x, name, f); 00692 f.close(); 00693 }
void diskio::load_arma_ascii | ( | Mat< eT > & | x, | |
const std::string & | name, | |||
std::ifstream & | f | |||
) | [inline, static, inherited] |
Load a matrix in text format (human readable), with a header that indicates the matrix type as well as its dimensions.
Definition at line 702 of file diskio_meat.hpp.
References arma_print(), Mat< eT >::at(), Mat< eT >::col(), gen_txt_header(), Mat< eT >::n_cols, Mat< eT >::n_rows, Mat< eT >::reset(), Mat< eT >::row(), and Mat< eT >::set_size().
00703 { 00704 arma_extra_debug_sigprint(); 00705 00706 bool load_okay = true; 00707 00708 if(f.is_open() == false) 00709 { 00710 load_okay = false; 00711 arma_extra_debug_print("unable to read ", name); 00712 } 00713 else 00714 { 00715 std::string f_header; 00716 u32 f_n_rows; 00717 u32 f_n_cols; 00718 00719 f >> f_header; 00720 f >> f_n_rows; 00721 f >> f_n_cols; 00722 00723 if(f_header == diskio::gen_txt_header(x)) 00724 { 00725 x.set_size(f_n_rows, f_n_cols); 00726 00727 for(u32 row=0; row < x.n_rows; ++row) 00728 { 00729 for(u32 col=0; col < x.n_cols; ++col) 00730 { 00731 f >> x.at(row,col); 00732 } 00733 } 00734 00735 if(f.good() == false) 00736 { 00737 arma_print("trouble reading ", name); 00738 load_okay = false; 00739 } 00740 } 00741 else 00742 { 00743 arma_print("incorrect header in ", name ); 00744 load_okay = false; 00745 } 00746 00747 } 00748 00749 00750 if(load_okay == false) 00751 { 00752 x.reset(); 00753 } 00754 }
void diskio::load_arma_binary | ( | Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Load a matrix in binary format, with a header that indicates the matrix type as well as its dimensions.
Definition at line 763 of file diskio_meat.hpp.
Referenced by Mat< eT >::load(), load_auto_detect(), and load_field_arma_binary().
00764 { 00765 arma_extra_debug_sigprint(); 00766 00767 std::ifstream f; 00768 f.open(name.c_str(), std::fstream::binary); 00769 diskio::load_arma_binary(x, name, f); 00770 f.close(); 00771 }
void diskio::load_arma_binary | ( | Mat< eT > & | x, | |
const std::string & | name, | |||
std::ifstream & | f | |||
) | [inline, static, inherited] |
Definition at line 778 of file diskio_meat.hpp.
References arma_print(), gen_bin_header(), Mat< eT >::memptr(), Mat< eT >::n_elem, Mat< eT >::reset(), and Mat< eT >::set_size().
00779 { 00780 arma_extra_debug_sigprint(); 00781 00782 bool load_okay = true; 00783 00784 if(f.is_open() == false) 00785 { 00786 load_okay = false; 00787 arma_extra_debug_print("unable to read ", name); 00788 } 00789 else 00790 { 00791 std::string f_header; 00792 u32 f_n_rows; 00793 u32 f_n_cols; 00794 00795 f >> f_header; 00796 f >> f_n_rows; 00797 f >> f_n_cols; 00798 00799 if(f_header == diskio::gen_bin_header(x)) 00800 { 00801 //f.seekg(1, ios::cur); // NOTE: this may not be portable, as on a Windows machine a newline could be two characters 00802 f.get(); 00803 00804 x.set_size(f_n_rows,f_n_cols); 00805 f.read( reinterpret_cast<char *>(x.memptr()), x.n_elem*sizeof(eT)); 00806 00807 if(f.good() == false) 00808 { 00809 arma_print("trouble reading ", name); 00810 load_okay = false; 00811 } 00812 } 00813 else 00814 { 00815 arma_print("incorrect header in ", name); 00816 load_okay = false; 00817 } 00818 00819 } 00820 00821 if(load_okay == false) 00822 { 00823 x.reset(); 00824 } 00825 }
void diskio::pnm_skip_comments | ( | std::fstream & | f | ) | [inline, static, inherited] |
Definition at line 831 of file diskio_meat.hpp.
Referenced by load_field_ppm_binary(), and load_pgm_binary().
00832 { 00833 while( isspace(f.peek()) ) 00834 { 00835 while( isspace(f.peek()) ) 00836 f.get(); 00837 00838 if(f.peek() == '#') 00839 { 00840 while( (f.peek() != '\r') && (f.peek()!='\n') ) 00841 f.get(); 00842 } 00843 } 00844 }
void diskio::load_pgm_binary | ( | Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Load a PGM greyscale image as a matrix.
Definition at line 852 of file diskio_meat.hpp.
References arma_print(), Mat< eT >::at(), Mat< eT >::col(), podarray< T1 >::memptr(), Mat< eT >::n_elem, pnm_skip_comments(), Mat< eT >::reset(), Mat< eT >::row(), and Mat< eT >::set_size().
Referenced by Mat< eT >::load(), and load_auto_detect().
00853 { 00854 arma_extra_debug_sigprint(); 00855 00856 std::fstream f; 00857 f.open(name.c_str(), std::fstream::in | std::fstream::binary); 00858 00859 bool load_okay = true; 00860 00861 if(f.is_open() == false) 00862 { 00863 load_okay = false; 00864 arma_extra_debug_print("unable to read ", name); 00865 } 00866 else 00867 { 00868 std::string f_header; 00869 f >> f_header; 00870 00871 if(f_header == "P5") 00872 { 00873 u32 f_n_rows = 0; 00874 u32 f_n_cols = 0; 00875 int f_maxval = 0; 00876 00877 diskio::pnm_skip_comments(f); 00878 00879 f >> f_n_cols; 00880 diskio::pnm_skip_comments(f); 00881 00882 f >> f_n_rows; 00883 diskio::pnm_skip_comments(f); 00884 00885 f >> f_maxval; 00886 f.get(); 00887 00888 if( (f_maxval > 0) || (f_maxval <= 65535) ) 00889 { 00890 x.set_size(f_n_rows,f_n_cols); 00891 00892 if(f_maxval <= 255) 00893 { 00894 const u32 n_elem = f_n_cols*f_n_rows; 00895 podarray<u8> tmp(n_elem); 00896 00897 f.read( reinterpret_cast<char*>(tmp.memptr()), n_elem); 00898 00899 u32 i = 0; 00900 00901 //cout << "f_n_cols = " << f_n_cols << endl; 00902 //cout << "f_n_rows = " << f_n_rows << endl; 00903 00904 00905 for(u32 row=0; row < f_n_rows; ++row) 00906 { 00907 for(u32 col=0; col < f_n_cols; ++col) 00908 { 00909 x.at(row,col) = eT(tmp[i]); 00910 ++i; 00911 } 00912 00913 } 00914 } 00915 else 00916 { 00917 const u32 n_elem = f_n_cols*f_n_rows; 00918 podarray<u16> tmp(n_elem); 00919 00920 f.read( reinterpret_cast<char *>(tmp.memptr()), n_elem*2); 00921 00922 u32 i = 0; 00923 00924 for(u32 row=0; row < f_n_rows; ++row) 00925 { 00926 for(u32 col=0; col < f_n_cols; ++col) 00927 { 00928 x.at(row,col) = eT(tmp[i]); 00929 ++i; 00930 } 00931 00932 } 00933 00934 } 00935 00936 } 00937 00938 if(f.good() == false) 00939 { 00940 arma_print("trouble reading ", name); 00941 load_okay = false; 00942 } 00943 } 00944 else 00945 { 00946 arma_print("unsupported header in ", name); 00947 load_okay = false; 00948 } 00949 00950 f.close(); 00951 } 00952 00953 00954 if(load_okay == false) 00955 { 00956 x.reset(); 00957 } 00958 }
void diskio::load_pgm_binary | ( | Mat< std::complex< T > > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Load a PGM greyscale image as a matrix.
Definition at line 966 of file diskio_meat.hpp.
References Mat< eT >::load().
00967 { 00968 arma_extra_debug_sigprint(); 00969 00970 uchar_mat tmp; 00971 tmp.load(name); 00972 x = conv_to< Mat< std::complex<T> > >::from(tmp); 00973 }
void diskio::load_auto_detect | ( | Mat< eT > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Try to load a matrix by automatically determining its type.
Definition at line 981 of file diskio_meat.hpp.
References load_arma_ascii(), load_arma_binary(), load_pgm_binary(), load_raw_ascii(), and Mat< eT >::reset().
Referenced by Mat< eT >::load().
00982 { 00983 arma_extra_debug_sigprint(); 00984 00985 static const std::string ARMA_MAT_TXT = "ARMA_MAT_TXT"; 00986 static const std::string ARMA_MAT_BIN = "ARMA_MAT_BIN"; 00987 static const std::string P5 = "P5"; 00988 00989 std::fstream f; 00990 f.open(name.c_str(), std::fstream::in | std::fstream::binary); 00991 00992 if(f.is_open() == false) 00993 { 00994 x.reset(); 00995 arma_extra_debug_print("unable to read ", name); 00996 } 00997 else 00998 { 00999 podarray<char> raw_header(ARMA_MAT_TXT.length() + 1); 01000 01001 f.read(raw_header.memptr(), ARMA_MAT_TXT.length()); 01002 raw_header[ARMA_MAT_TXT.length()] = '\0'; 01003 01004 const std::string header = raw_header.mem; 01005 01006 if(ARMA_MAT_TXT == header.substr(0,ARMA_MAT_TXT.length())) 01007 { 01008 load_arma_ascii(x, name); 01009 } 01010 else 01011 if(ARMA_MAT_BIN == header.substr(0,ARMA_MAT_BIN.length())) 01012 { 01013 load_arma_binary(x, name); 01014 } 01015 else 01016 if(P5 == header.substr(0,P5.length())) 01017 { 01018 load_pgm_binary(x, name); 01019 } 01020 else 01021 { 01022 load_raw_ascii(x, name); 01023 } 01024 01025 f.close(); 01026 } 01027 01028 }
void diskio::save_field_arma_binary | ( | const field< T1 > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Definition at line 1035 of file diskio_meat.hpp.
References arma_print(), arma_warn(), gen_tmp_name(), field< oT >::n_cols, field< oT >::n_elem, field< oT >::n_rows, safe_rename(), and save_arma_binary().
Referenced by field_aux::save().
01036 { 01037 arma_extra_debug_sigprint(); 01038 01039 arma_type_check<is_Mat<T1>::value == false>::apply(); 01040 01041 const std::string tmp_name = diskio::gen_tmp_name(final_name); 01042 std::ofstream f( tmp_name.c_str(), std::fstream::binary ); 01043 01044 if(f.is_open() == false) 01045 { 01046 arma_print("couldn't write ", tmp_name); 01047 } 01048 else 01049 { 01050 f << "ARMA_FLD_BIN" << '\n'; 01051 f << x.n_rows << '\n'; 01052 f << x.n_cols << '\n'; 01053 01054 for(u32 i=0; i<x.n_elem; ++i) 01055 { 01056 diskio::save_arma_binary(x[i], tmp_name, f); 01057 } 01058 01059 const bool writing_problem = (f.good() == false); 01060 01061 arma_warn(writing_problem, "trouble writing ", tmp_name ); 01062 01063 f.flush(); 01064 f.close(); 01065 01066 if(writing_problem == false) 01067 { 01068 diskio::safe_rename(tmp_name, final_name); 01069 } 01070 01071 } 01072 01073 }
void diskio::load_field_arma_binary | ( | field< T1 > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Definition at line 1080 of file diskio_meat.hpp.
References arma_print(), load_arma_binary(), field< oT >::n_elem, field< oT >::reset(), and field< oT >::set_size().
Referenced by field_aux::load(), and load_field_auto_detect().
01081 { 01082 arma_extra_debug_sigprint(); 01083 01084 arma_type_check<is_Mat<T1>::value == false>::apply(); 01085 01086 bool load_okay = true; 01087 01088 std::ifstream f( name.c_str() ); 01089 01090 if(f.fail()) 01091 { 01092 load_okay = false; 01093 arma_extra_debug_print("unable to read ", name); 01094 } 01095 else 01096 { 01097 std::string f_type; 01098 f >> f_type; 01099 01100 if(f_type != "ARMA_FLD_BIN") 01101 { 01102 arma_print("unsupported field type in ", name); 01103 load_okay = false; 01104 } 01105 else 01106 { 01107 u32 f_n_rows; 01108 u32 f_n_cols; 01109 01110 f >> f_n_rows; 01111 f >> f_n_cols; 01112 01113 x.set_size(f_n_rows, f_n_cols); 01114 01115 f.get(); 01116 01117 for(u32 i=0; i<x.n_elem; ++i) 01118 { 01119 diskio::load_arma_binary(x[i], name, f); 01120 01121 if(f.good() == false) 01122 { 01123 arma_print("trouble reading ", name); 01124 load_okay = false; 01125 break; 01126 } 01127 } 01128 } 01129 } 01130 01131 f.close(); 01132 01133 01134 if(load_okay == false) 01135 { 01136 x.reset(); 01137 } 01138 }
void diskio::save_field_ppm_binary | ( | const field< T1 > & | x, | |
const std::string & | final_name | |||
) | [inline, static, inherited] |
Definition at line 1145 of file diskio_meat.hpp.
References arma_print(), arma_warn(), Mat< eT >::at(), Mat< eT >::col(), gen_tmp_name(), podarray< T1 >::mem, Mat< eT >::n_cols, Mat< eT >::n_elem, field< oT >::n_elem, Mat< eT >::n_rows, Mat< eT >::row(), and safe_rename().
Referenced by field_aux::save().
01146 { 01147 arma_extra_debug_sigprint(); 01148 01149 arma_type_check<is_Mat<T1>::value == false>::apply(); 01150 typedef typename T1::elem_type eT; 01151 01152 arma_debug_check( (x.n_elem != 3), "diskio::save_field_ppm_binary(): given field must have exactly 3 matrices of equal size" ); 01153 01154 bool same_size = true; 01155 for(u32 i=1; i<3; ++i) 01156 { 01157 if( (x(0).n_rows != x(i).n_rows) || (x(0).n_cols != x(i).n_cols) ) 01158 { 01159 same_size = false; 01160 break; 01161 } 01162 } 01163 01164 arma_debug_check( (same_size != true), "diskio::save_field_ppm_binary(): given field must have exactly 3 matrices of equal size" ); 01165 01166 const Mat<eT>& R = x(0); 01167 const Mat<eT>& G = x(1); 01168 const Mat<eT>& B = x(2); 01169 01170 const std::string tmp_name = diskio::gen_tmp_name(final_name); 01171 std::ofstream f( tmp_name.c_str(), std::fstream::binary ); 01172 01173 if(f.is_open() == false) 01174 { 01175 arma_print("couldn't write ", tmp_name); 01176 } 01177 else 01178 { 01179 f << "P6" << '\n'; 01180 f << R.n_cols << '\n'; 01181 f << R.n_rows << '\n'; 01182 f << 255 << '\n'; 01183 01184 const u32 n_elem = 3 * R.n_rows * R.n_cols; 01185 podarray<u8> tmp(n_elem); 01186 01187 u32 i = 0; 01188 for(u32 row=0; row < R.n_rows; ++row) 01189 { 01190 for(u32 col=0; col < R.n_cols; ++col) 01191 { 01192 tmp[i+0] = u8( R.at(row,col) ); 01193 tmp[i+1] = u8( G.at(row,col) ); 01194 tmp[i+2] = u8( B.at(row,col) ); 01195 01196 i+=3; 01197 } 01198 } 01199 01200 f.write(reinterpret_cast<const char*>(tmp.mem), n_elem); 01201 01202 const bool writing_problem = (f.good() == false); 01203 01204 arma_warn(writing_problem, "trouble writing ", tmp_name ); 01205 01206 f.flush(); 01207 f.close(); 01208 01209 if(writing_problem == false) 01210 { 01211 diskio::safe_rename(tmp_name, final_name); 01212 } 01213 01214 } 01215 01216 }
void diskio::load_field_ppm_binary | ( | field< T1 > & | x, | |
const std::string & | final_name | |||
) | [inline, static, inherited] |
Definition at line 1223 of file diskio_meat.hpp.
References arma_print(), Mat< eT >::at(), Mat< eT >::col(), podarray< T1 >::memptr(), Mat< eT >::n_elem, pnm_skip_comments(), field< oT >::reset(), Mat< eT >::row(), Mat< eT >::set_size(), and field< oT >::set_size().
Referenced by field_aux::load(), and load_field_auto_detect().
01224 { 01225 arma_extra_debug_sigprint(); 01226 01227 arma_type_check<is_Mat<T1>::value == false>::apply(); 01228 typedef typename T1::elem_type eT; 01229 01230 std::fstream f; 01231 f.open(name.c_str(), std::fstream::in | std::fstream::binary); 01232 01233 bool load_okay = true; 01234 01235 if(f.is_open() == false) 01236 { 01237 load_okay = false; 01238 arma_extra_debug_print("unable to read ", name); 01239 } 01240 else 01241 { 01242 std::string f_header; 01243 f >> f_header; 01244 01245 if(f_header == "P6") 01246 { 01247 u32 f_n_rows = 0; 01248 u32 f_n_cols = 0; 01249 int f_maxval = 0; 01250 01251 diskio::pnm_skip_comments(f); 01252 01253 f >> f_n_cols; 01254 diskio::pnm_skip_comments(f); 01255 01256 f >> f_n_rows; 01257 diskio::pnm_skip_comments(f); 01258 01259 f >> f_maxval; 01260 f.get(); 01261 01262 if( (f_maxval > 0) || (f_maxval <= 65535) ) 01263 { 01264 x.set_size(3); 01265 Mat<eT>& R = x(0); 01266 Mat<eT>& G = x(1); 01267 Mat<eT>& B = x(2); 01268 01269 R.set_size(f_n_rows,f_n_cols); 01270 G.set_size(f_n_rows,f_n_cols); 01271 B.set_size(f_n_rows,f_n_cols); 01272 01273 if(f_maxval <= 255) 01274 { 01275 const u32 n_elem = 3*f_n_cols*f_n_rows; 01276 podarray<u8> tmp(n_elem); 01277 01278 f.read( reinterpret_cast<char*>(tmp.memptr()), n_elem); 01279 01280 u32 i = 0; 01281 01282 //cout << "f_n_cols = " << f_n_cols << endl; 01283 //cout << "f_n_rows = " << f_n_rows << endl; 01284 01285 01286 for(u32 row=0; row < f_n_rows; ++row) 01287 { 01288 for(u32 col=0; col < f_n_cols; ++col) 01289 { 01290 R.at(row,col) = eT(tmp[i+0]); 01291 G.at(row,col) = eT(tmp[i+1]); 01292 B.at(row,col) = eT(tmp[i+2]); 01293 i+=3; 01294 } 01295 01296 } 01297 } 01298 else 01299 { 01300 const u32 n_elem = 3*f_n_cols*f_n_rows; 01301 podarray<u16> tmp(n_elem); 01302 01303 f.read( reinterpret_cast<char *>(tmp.memptr()), 2*n_elem); 01304 01305 u32 i = 0; 01306 01307 for(u32 row=0; row < f_n_rows; ++row) 01308 { 01309 for(u32 col=0; col < f_n_cols; ++col) 01310 { 01311 R.at(row,col) = eT(tmp[i+0]); 01312 G.at(row,col) = eT(tmp[i+1]); 01313 B.at(row,col) = eT(tmp[i+2]); 01314 i+=3; 01315 } 01316 01317 } 01318 01319 } 01320 01321 } 01322 01323 if(f.good() == false) 01324 { 01325 arma_print("trouble reading ", name); 01326 load_okay = false; 01327 } 01328 01329 } 01330 else 01331 { 01332 arma_print("unsupported header in ", name); 01333 load_okay = false; 01334 } 01335 01336 f.close(); 01337 } 01338 01339 01340 if(load_okay == false) 01341 { 01342 x.reset(); 01343 } 01344 01345 }
void diskio::save_field_std_string | ( | const field< std::string > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Definition at line 1351 of file diskio_meat.hpp.
References arma_print(), arma_warn(), field< oT >::at(), Mat< eT >::col(), gen_tmp_name(), field< oT >::n_cols, field< oT >::n_rows, Mat< eT >::row(), and safe_rename().
Referenced by field_aux::save().
01352 { 01353 arma_extra_debug_sigprint(); 01354 01355 const std::string tmp_name = diskio::gen_tmp_name(final_name); 01356 std::ofstream f( tmp_name.c_str(), std::fstream::binary ); 01357 01358 if(f.is_open() == false) 01359 { 01360 arma_print("couldn't write ", tmp_name); 01361 } 01362 else 01363 { 01364 for(u32 row=0; row<x.n_rows; ++row) 01365 for(u32 col=0; col<x.n_cols; ++col) 01366 { 01367 f << x.at(row,col); 01368 01369 if(col < x.n_cols-1) 01370 { 01371 f << ' '; 01372 } 01373 else 01374 { 01375 f << '\n'; 01376 } 01377 } 01378 01379 const bool writing_problem = (f.good() == false); 01380 01381 arma_warn(writing_problem, "trouble writing ", tmp_name ); 01382 01383 f.flush(); 01384 f.close(); 01385 01386 if(writing_problem == false) 01387 { 01388 diskio::safe_rename(tmp_name, final_name); 01389 } 01390 01391 } 01392 01393 }
void diskio::load_field_std_string | ( | field< std::string > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Definition at line 1399 of file diskio_meat.hpp.
References arma_print(), field< oT >::at(), Mat< eT >::col(), field< oT >::n_cols, field< oT >::n_rows, field< oT >::reset(), Mat< eT >::row(), and field< oT >::set_size().
Referenced by field_aux::load().
01400 { 01401 arma_extra_debug_sigprint(); 01402 01403 bool load_okay = true; 01404 01405 std::ifstream f( name.c_str() ); 01406 01407 if(f.fail()) 01408 { 01409 load_okay = false; 01410 arma_extra_debug_print("unable to read ", name); 01411 } 01412 else 01413 { 01414 // 01415 // work out the size 01416 01417 u32 f_n_rows = 0; 01418 u32 f_n_cols = 0; 01419 01420 bool f_n_cols_found = false; 01421 01422 std::string line_string; 01423 std::string token; 01424 01425 while( (f.good() == true) && (load_okay == true) ) 01426 { 01427 std::getline(f, line_string); 01428 if(line_string.size() == 0) 01429 break; 01430 01431 std::stringstream line_stream(line_string); 01432 01433 u32 line_n_cols = 0; 01434 while (line_stream >> token) 01435 line_n_cols++; 01436 01437 if(f_n_cols_found == false) 01438 { 01439 f_n_cols = line_n_cols; 01440 f_n_cols_found = true; 01441 } 01442 else 01443 { 01444 if(line_n_cols != f_n_cols) 01445 { 01446 load_okay = false; 01447 arma_print("inconsistent number of columns in ", name ); 01448 } 01449 } 01450 01451 ++f_n_rows; 01452 } 01453 01454 if(load_okay == true) 01455 { 01456 f.clear(); 01457 f.seekg(0, ios::beg); 01458 //f.seekg(start); 01459 01460 x.set_size(f_n_rows, f_n_cols); 01461 01462 for(u32 row=0; row < x.n_rows; ++row) 01463 { 01464 for(u32 col=0; col < x.n_cols; ++col) 01465 { 01466 f >> x.at(row,col); 01467 } 01468 } 01469 } 01470 01471 if(f.good() == false) 01472 { 01473 load_okay = false; 01474 arma_print("trouble reading ", name ); 01475 } 01476 01477 f.close(); 01478 } 01479 01480 01481 if(load_okay == false) 01482 { 01483 x.reset(); 01484 } 01485 01486 }
void diskio::load_field_auto_detect | ( | field< T1 > & | x, | |
const std::string & | name | |||
) | [inline, static, inherited] |
Try to load a field by automatically determining its type.
Definition at line 1494 of file diskio_meat.hpp.
References arma_print(), load_field_arma_binary(), load_field_ppm_binary(), and field< oT >::reset().
Referenced by field_aux::load().
01495 { 01496 arma_extra_debug_sigprint(); 01497 01498 arma_type_check<is_Mat<T1>::value == false>::apply(); 01499 01500 static const std::string ARMA_FLD_BIN = "ARMA_FLD_BIN"; 01501 static const std::string P6 = "P6"; 01502 01503 std::fstream f; 01504 f.open(name.c_str(), std::fstream::in | std::fstream::binary); 01505 01506 if(f.is_open() == false) 01507 { 01508 x.reset(); 01509 arma_extra_debug_print("unable to read ", name); 01510 } 01511 else 01512 { 01513 podarray<char> raw_header(ARMA_FLD_BIN.length() + 1); 01514 01515 f.read(raw_header.memptr(), ARMA_FLD_BIN.length()); 01516 raw_header[ARMA_FLD_BIN.length()] = '\0'; 01517 01518 const std::string header = raw_header.mem; 01519 01520 if(ARMA_FLD_BIN == header.substr(0,ARMA_FLD_BIN.length())) 01521 { 01522 load_field_arma_binary(x, name); 01523 } 01524 else 01525 if(P6 == header.substr(0,P6.length())) 01526 { 01527 load_field_ppm_binary(x, name); 01528 } 01529 else 01530 { 01531 arma_print("unsupported header in ", name); 01532 x.reset(); 01533 } 01534 01535 f.close(); 01536 } 01537 01538 }