Diskio


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.

Enumeration Type Documentation

enum file_type

file types supported by Armadillo

Enumerator:
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   };


Function Documentation

template<typename eT >
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   }

template<typename eT >
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   else
00132   if(is_float<eT>::value == true)
00133     {
00134     return std::string("ARMA_MAT_BIN_FN004");
00135     }
00136   else
00137   if(is_double<eT>::value == true)
00138     {
00139     return std::string("ARMA_MAT_BIN_FN008");
00140     }
00141   else
00142   if(is_complex_float<eT>::value == true)
00143     {
00144     return std::string("ARMA_MAT_BIN_FC008");
00145     }
00146   else
00147   if(is_complex_double<eT>::value == true)
00148     {
00149     return std::string("ARMA_MAT_BIN_FC016");
00150     }
00151   else
00152     {
00153     return std::string();
00154     }
00155   
00156   }

char diskio::conv_to_hex_char ( const u8  x  )  [inline, static, inherited]

Definition at line 162 of file diskio_meat.hpp.

Referenced by conv_to_hex().

00163   {
00164   char out;
00165   switch(x)
00166     {
00167     case  0: out = '0'; break;
00168     case  1: out = '1'; break;
00169     case  2: out = '2'; break;
00170     case  3: out = '3'; break;
00171     case  4: out = '4'; break;
00172     case  5: out = '5'; break;
00173     case  6: out = '6'; break;
00174     case  7: out = '7'; break;
00175     case  8: out = '8'; break;
00176     case  9: out = '9'; break;
00177     case 10: out = 'a'; break;
00178     case 11: out = 'b'; break;
00179     case 12: out = 'c'; break;
00180     case 13: out = 'd'; break;
00181     case 14: out = 'e'; break;
00182     case 15: out = 'f'; break;
00183     default: out = '-'; break;
00184     }
00185 
00186   return out;  
00187   }

void diskio::conv_to_hex ( char *  out,
const u8  x 
) [inline, static, inherited]

Definition at line 193 of file diskio_meat.hpp.

References conv_to_hex_char().

Referenced by gen_tmp_name().

00194   {
00195   const u8 a = x / 16;
00196   const u8 b = x - 16*a;
00197 
00198   out[0] = conv_to_hex_char(a);
00199   out[1] = conv_to_hex_char(b);
00200   }

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 213 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().

00214   {
00215   const std::string* ptr_x     = &x;
00216   const u8*          ptr_ptr_x = reinterpret_cast<const u8*>(&ptr_x);
00217   
00218   const char* extra      = ".tmp_";
00219   const u32   extra_size = 5;
00220   
00221   const u32   tmp_size   = 2*sizeof(u8*) + 2*2;
00222         char  tmp[tmp_size];
00223   
00224   u32 char_count = 0;
00225   
00226   for(u32 i=0; i<sizeof(u8*); ++i)
00227     {
00228     conv_to_hex(&tmp[char_count], ptr_ptr_x[i]);
00229     char_count += 2;
00230     }
00231   
00232   const u32 x_size = x.size();
00233   u8 sum = 0;
00234   
00235   for(u32 i=0; i<x_size; ++i)
00236     {
00237     sum += u8(x[i]);
00238     }
00239   
00240   conv_to_hex(&tmp[char_count], sum);
00241   char_count += 2;
00242   
00243   conv_to_hex(&tmp[char_count], u8(x_size));
00244   
00245   
00246   std::string out;
00247   out.resize(x_size + extra_size + tmp_size);
00248   
00249   
00250   for(u32 i=0; i<x_size; ++i)
00251     {
00252     out[i] = x[i];
00253     }
00254   
00255   for(u32 i=0; i<extra_size; ++i)
00256     {
00257     out[x_size + i] = extra[i];
00258     }
00259   
00260   for(u32 i=0; i<tmp_size; ++i)
00261     {
00262     out[x_size + extra_size + i] = tmp[i];
00263     }
00264   
00265   return out;
00266   }

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 277 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().

00278   {
00279   std::fstream f(new_name.c_str(), std::fstream::out | std::fstream::app);
00280   f.put(' ');
00281   
00282   const bool writing_problem = (f.good() == false);
00283   f.close();
00284   
00285   arma_warn( writing_problem, "trouble writing ", new_name );
00286   
00287   if(writing_problem == false)
00288     {
00289     std::remove(new_name.c_str());
00290     
00291     const int mv_result = std::rename(old_name.c_str(), new_name.c_str());
00292     arma_warn( (mv_result != 0), "trouble writing ", new_name );
00293     }
00294   
00295   }

template<typename eT >
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 304 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().

00305   {
00306   arma_extra_debug_sigprint();
00307   
00308   const std::string tmp_name = diskio::gen_tmp_name(final_name);
00309   
00310   std::fstream f(tmp_name.c_str(), std::fstream::out);
00311   
00312   if(f.is_open() == false)
00313     {
00314     arma_print("unable to write ", tmp_name);
00315     }
00316   else
00317     {
00318     u32 cell_width;
00319     
00320     // TODO: need sane values for complex numbers
00321     
00322     if( (is_float<eT>::value == true) || (is_double<eT>::value == true) )
00323       {
00324       f.setf(ios::scientific);
00325       f.precision(8);
00326       cell_width = 16;
00327       }
00328     
00329     for(u32 row=0; row < x.n_rows; ++row)
00330       {
00331       for(u32 col=0; col < x.n_cols; ++col)
00332         {
00333         f.put(' ');
00334         
00335         if( (is_float<eT>::value == true) || (is_double<eT>::value == true) )
00336           {
00337           f.width(cell_width);
00338           }
00339         
00340         f << x.at(row,col);
00341         }
00342         
00343       f.put('\n');
00344       }
00345     
00346     const bool writing_problem = (f.good() == false);
00347     
00348     arma_warn(writing_problem, "trouble writing ", tmp_name );
00349     
00350     f.flush();
00351     f.close();
00352     
00353     if(writing_problem == false)
00354       {
00355       diskio::safe_rename(tmp_name, final_name);
00356       }
00357     }
00358   
00359   }

template<typename eT >
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 368 of file diskio_meat.hpp.

References arma_warn(), gen_tmp_name(), and safe_rename().

Referenced by Mat< eT >::save().

00369   {
00370   arma_extra_debug_sigprint();
00371   
00372   const std::string tmp_name = diskio::gen_tmp_name(final_name);
00373   
00374   std::ofstream f(tmp_name.c_str());
00375   
00376   diskio::save_arma_ascii(x, tmp_name, f);
00377   
00378   const bool writing_problem = (f.good() == false);
00379   
00380   f.flush();
00381   f.close();
00382   
00383   arma_warn( writing_problem, "trouble writing ", tmp_name );
00384   
00385   if(writing_problem == false)
00386     {
00387     diskio::safe_rename(tmp_name, final_name);
00388     }
00389   }

template<typename eT >
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 398 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().

00399   {
00400   arma_extra_debug_sigprint();
00401   
00402   if(f.is_open() == false)
00403     {
00404     arma_debug_print("unable to write ", name);
00405     }
00406   else
00407     {
00408     const ios::fmtflags orig_flags = f.flags();
00409     
00410     f << diskio::gen_txt_header(x) << '\n';
00411     f << x.n_rows << ' ' << x.n_cols << '\n';
00412     
00413     u32 cell_width;
00414     
00415     // TODO: need sane values for complex numbers
00416     
00417     if( (is_float<eT>::value == true) || (is_double<eT>::value == true) )
00418       {
00419       f.setf(ios::scientific);
00420       f.precision(8);
00421       cell_width = 16;
00422       }
00423       
00424     for(u32 row=0; row < x.n_rows; ++row)
00425       {
00426       for(u32 col=0; col < x.n_cols; ++col)
00427         {
00428         f.put(' ');
00429         
00430         if( (is_float<eT>::value == true) || (is_double<eT>::value == true) )        
00431           {
00432           f.width(cell_width);
00433           }
00434         
00435         f << x.at(row,col);
00436         }
00437       
00438       f.put('\n');
00439       }
00440     
00441     f.flags(orig_flags);
00442     }
00443   }

template<typename eT >
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 452 of file diskio_meat.hpp.

References arma_warn(), gen_tmp_name(), and safe_rename().

Referenced by Mat< eT >::save(), and save_field_arma_binary().

00453   {
00454   arma_extra_debug_sigprint();
00455   
00456   const std::string tmp_name = diskio::gen_tmp_name(final_name);
00457   
00458   std::ofstream f(tmp_name.c_str(), std::fstream::binary);
00459   
00460   diskio::save_arma_binary(x, tmp_name, f);
00461   
00462   const bool writing_problem = (f.good() == false);
00463   
00464   f.flush();
00465   f.close();
00466   
00467   arma_warn( writing_problem, "trouble writing ", tmp_name );
00468   
00469   if(writing_problem == false)
00470     {
00471     diskio::safe_rename(tmp_name, final_name);
00472     }
00473   }

template<typename eT >
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 482 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.

00483   {
00484   arma_extra_debug_sigprint();
00485   
00486   if(f.is_open() == false)
00487     {
00488     arma_print("unable to write ", name);
00489     }
00490   else
00491     {
00492     f << diskio::gen_bin_header(x) << '\n';
00493     f << x.n_rows << ' ' << x.n_cols << '\n';
00494     
00495     f.write(reinterpret_cast<const char*>(x.mem), x.n_elem*sizeof(eT));
00496     }
00497   
00498   }

template<typename eT >
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 510 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().

00511   {
00512   arma_extra_debug_sigprint();
00513   
00514   const std::string tmp_name = diskio::gen_tmp_name(final_name);
00515   
00516   std::fstream f(tmp_name.c_str(), std::fstream::out | std::fstream::binary);
00517   
00518   if(f.is_open() == false)
00519     {
00520     arma_print("unable to write ", tmp_name);
00521     }
00522   else
00523     {
00524     f << "P5" << '\n';
00525     f << x.n_cols << ' ' << x.n_rows << '\n';
00526     f << 255 << '\n';
00527     
00528     const u32 n_elem = x.n_rows * x.n_cols;
00529     podarray<u8> tmp(n_elem);
00530     
00531     u32 i = 0;
00532     
00533     for(u32 row=0; row < x.n_rows; ++row)
00534       {
00535       for(u32 col=0; col < x.n_cols; ++col)
00536         {
00537         tmp[i] = u8( x(row,col) );  // TODO: add round() ?
00538         ++i;
00539         }
00540       }
00541     
00542     f.write(reinterpret_cast<const char*>(tmp.mem), n_elem);
00543     
00544     const bool writing_problem = (f.good() == false);
00545     
00546     arma_warn(writing_problem, "trouble writing ", tmp_name );
00547     
00548     f.flush();
00549     f.close();
00550     
00551     if(writing_problem == false)
00552       {
00553       diskio::safe_rename(tmp_name, final_name);
00554       }
00555     }
00556   
00557   }

template<typename T >
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 565 of file diskio_meat.hpp.

References save_pgm_binary().

00566   {
00567   arma_extra_debug_sigprint();
00568   
00569   const uchar_mat tmp = conv_to<uchar_mat>::from(x);
00570   diskio::save_pgm_binary(tmp,name);
00571   }

template<typename eT >
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 581 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().

00582   {
00583   arma_extra_debug_sigprint();
00584 
00585   std::fstream f;
00586   f.open(name.c_str(), std::fstream::in);
00587   
00588   bool load_okay = true;
00589   
00590   if(f.is_open() == false)
00591     {
00592     load_okay = false;
00593     arma_extra_debug_print("unable to read ", name);
00594     }
00595   else
00596     {
00597     //std::fstream::pos_type start = f.tellg();
00598     
00599     //
00600     // work out the size
00601     
00602     
00603     u32 f_n_rows = 0;
00604     u32 f_n_cols = 0;
00605     
00606     bool f_n_cols_found = false;
00607     
00608     std::string line_string;
00609     std::string token;
00610     
00611     while( (f.good() == true) && (load_okay == true) )
00612       {
00613       std::getline(f, line_string);
00614       if(line_string.size() == 0)
00615         break;
00616       
00617       std::stringstream line_stream(line_string);
00618       
00619       u32 line_n_cols = 0;
00620       while (line_stream >> token)
00621         line_n_cols++;
00622       
00623       if(f_n_cols_found == false)
00624         {
00625         f_n_cols = line_n_cols;
00626         f_n_cols_found = true;
00627         }
00628       else
00629         {
00630         if(line_n_cols != f_n_cols)
00631           {
00632           arma_print("inconsistent number of columns in ", name );
00633           load_okay = false;
00634           }
00635         }
00636       
00637       ++f_n_rows;
00638       }
00639       
00640     if(load_okay == true)
00641       {
00642       f.clear();
00643       f.seekg(0, ios::beg);
00644       //f.seekg(start);
00645       
00646       x.set_size(f_n_rows, f_n_cols);
00647     
00648       eT val;
00649       
00650       for(u32 row=0; row < x.n_rows; ++row)
00651         {
00652         for(u32 col=0; col < x.n_cols; ++col)
00653           {
00654           // f >> token;
00655           // x.at(row,col) = eT( strtod(token.c_str(), 0) );
00656           
00657           f >> val;
00658           x.at(row,col) = val;
00659           }
00660         }
00661       }
00662     
00663     if(f.good() == false)
00664       {
00665       arma_print("trouble reading ", name );
00666       load_okay = false; 
00667       }
00668     
00669     f.close();
00670     }
00671   
00672   
00673   if(load_okay == false)
00674     {
00675     x.reset();
00676     }
00677   
00678   }

template<typename eT >
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 687 of file diskio_meat.hpp.

Referenced by Mat< eT >::load(), and load_auto_detect().

00688   {
00689   arma_extra_debug_sigprint();
00690   
00691   std::ifstream f(name.c_str());
00692   diskio::load_arma_ascii(x, name, f);
00693   f.close();
00694   }

template<typename eT >
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 703 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().

00704   {
00705   arma_extra_debug_sigprint();
00706   
00707   bool load_okay = true;
00708   
00709   if(f.is_open() == false)
00710     {
00711     load_okay = false;
00712     arma_extra_debug_print("unable to read ", name);
00713     }
00714   else
00715     {
00716     std::string f_header;
00717     u32 f_n_rows;
00718     u32 f_n_cols;
00719     
00720     f >> f_header;
00721     f >> f_n_rows;
00722     f >> f_n_cols;
00723     
00724     if(f_header == diskio::gen_txt_header(x))
00725       {
00726       x.set_size(f_n_rows, f_n_cols);
00727       
00728       for(u32 row=0; row < x.n_rows; ++row)
00729         {
00730         for(u32 col=0; col < x.n_cols; ++col)
00731           {
00732           f >> x.at(row,col);
00733           }
00734         }
00735       
00736       if(f.good() == false)
00737         {
00738         arma_print("trouble reading ", name);
00739         load_okay = false;
00740         }
00741       }
00742     else
00743       {
00744       arma_print("incorrect header in ", name );
00745       load_okay = false;
00746       }
00747   
00748     }
00749   
00750   
00751   if(load_okay == false)
00752     {
00753     x.reset();
00754     }
00755   }

template<typename eT >
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 764 of file diskio_meat.hpp.

Referenced by Mat< eT >::load(), load_auto_detect(), and load_field_arma_binary().

00765   {
00766   arma_extra_debug_sigprint();
00767   
00768   std::ifstream f;
00769   f.open(name.c_str(), std::fstream::binary);
00770   diskio::load_arma_binary(x, name, f);
00771   f.close();
00772   }

template<typename eT >
void diskio::load_arma_binary ( Mat< eT > &  x,
const std::string &  name,
std::ifstream &  f 
) [inline, static, inherited]

Definition at line 779 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().

00780   {
00781   arma_extra_debug_sigprint();
00782   
00783   bool load_okay = true;
00784   
00785   if(f.is_open() == false)
00786     {
00787     load_okay = false;
00788     arma_extra_debug_print("unable to read ", name);
00789     }
00790   else
00791     {
00792     std::string f_header;
00793     u32 f_n_rows;
00794     u32 f_n_cols;
00795     
00796     f >> f_header;
00797     f >> f_n_rows;
00798     f >> f_n_cols;
00799     
00800     if(f_header == diskio::gen_bin_header(x))
00801       {
00802       //f.seekg(1, ios::cur);  // NOTE: this may not be portable, as on a Windows machine a newline could be two characters
00803       f.get();
00804       
00805       x.set_size(f_n_rows,f_n_cols);
00806       f.read( reinterpret_cast<char *>(x.memptr()), x.n_elem*sizeof(eT));
00807       
00808       if(f.good() == false)
00809         {
00810         arma_print("trouble reading ", name);
00811         load_okay = false;
00812         }
00813       }
00814     else
00815       {
00816       arma_print("incorrect header in ", name);
00817       load_okay = false;
00818       }
00819     
00820     }
00821   
00822   if(load_okay == false)
00823     {
00824     x.reset();
00825     }
00826   }

void diskio::pnm_skip_comments ( std::fstream &  f  )  [inline, static, inherited]

Definition at line 832 of file diskio_meat.hpp.

Referenced by load_field_ppm_binary(), and load_pgm_binary().

00833   {
00834   while( isspace(f.peek()) )
00835     {
00836     while( isspace(f.peek()) )
00837       f.get();
00838   
00839     if(f.peek() == '#')
00840       {
00841       while( (f.peek() != '\r') && (f.peek()!='\n') )
00842         f.get();
00843       }
00844     }
00845   }

template<typename eT >
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 853 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().

00854   {
00855   arma_extra_debug_sigprint();
00856   
00857   std::fstream f;
00858   f.open(name.c_str(), std::fstream::in | std::fstream::binary);
00859   
00860   bool load_okay = true;
00861   
00862   if(f.is_open() == false)
00863     {
00864     load_okay = false;
00865     arma_extra_debug_print("unable to read ", name);
00866     }
00867   else
00868     {
00869     std::string f_header;
00870     f >> f_header;
00871     
00872     if(f_header == "P5")
00873       {
00874       u32 f_n_rows = 0;
00875       u32 f_n_cols = 0;
00876       int f_maxval = 0;
00877     
00878       diskio::pnm_skip_comments(f);
00879     
00880       f >> f_n_cols;
00881       diskio::pnm_skip_comments(f);
00882     
00883       f >> f_n_rows;
00884       diskio::pnm_skip_comments(f);
00885     
00886       f >> f_maxval;
00887       f.get();
00888       
00889       if( (f_maxval > 0) || (f_maxval <= 65535) )
00890         {
00891         x.set_size(f_n_rows,f_n_cols);
00892         
00893         if(f_maxval <= 255)
00894           {
00895           const u32 n_elem = f_n_cols*f_n_rows;
00896           podarray<u8> tmp(n_elem);
00897           
00898           f.read( reinterpret_cast<char*>(tmp.memptr()), n_elem);
00899           
00900           u32 i = 0;
00901           
00902           //cout << "f_n_cols = " << f_n_cols << endl;
00903           //cout << "f_n_rows = " << f_n_rows << endl;
00904           
00905           
00906           for(u32 row=0; row < f_n_rows; ++row)
00907             {
00908             for(u32 col=0; col < f_n_cols; ++col)
00909               {
00910               x.at(row,col) = eT(tmp[i]);
00911               ++i;
00912               }
00913             
00914             }
00915           }
00916         else
00917           {
00918           const u32 n_elem = f_n_cols*f_n_rows;
00919           podarray<u16> tmp(n_elem);
00920           
00921           f.read( reinterpret_cast<char *>(tmp.memptr()), n_elem*2);
00922           
00923           u32 i = 0;
00924           
00925           for(u32 row=0; row < f_n_rows; ++row)
00926             {
00927             for(u32 col=0; col < f_n_cols; ++col)
00928               {
00929               x.at(row,col) = eT(tmp[i]);
00930               ++i;
00931               }
00932             
00933             }
00934           
00935           }
00936         
00937         }
00938       
00939       if(f.good() == false)
00940         {
00941         arma_print("trouble reading ", name);
00942         load_okay = false;
00943         }
00944       }
00945     else
00946       {
00947       arma_print("unsupported header in ", name);
00948       load_okay = false;
00949       }
00950     
00951     f.close();
00952     }
00953   
00954   
00955   if(load_okay == false)
00956     {
00957     x.reset();
00958     }
00959   }

template<typename T >
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 967 of file diskio_meat.hpp.

References Mat< eT >::load().

00968   {
00969   arma_extra_debug_sigprint();
00970   
00971   uchar_mat tmp;
00972   tmp.load(name);
00973   x = conv_to< Mat< std::complex<T> > >::from(tmp);
00974   }

template<typename eT >
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 982 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().

00983   {
00984   arma_extra_debug_sigprint();
00985   
00986   static const std::string ARMA_MAT_TXT = "ARMA_MAT_TXT";
00987   static const std::string ARMA_MAT_BIN = "ARMA_MAT_BIN";
00988   static const std::string           P5 = "P5";
00989   
00990   std::fstream f;
00991   f.open(name.c_str(), std::fstream::in | std::fstream::binary);
00992   
00993   if(f.is_open() == false)
00994     {
00995     x.reset();
00996     arma_extra_debug_print("unable to read ", name);
00997     }
00998   else
00999     {
01000     podarray<char> raw_header(ARMA_MAT_TXT.length() + 1);
01001     
01002     f.read(raw_header.memptr(), ARMA_MAT_TXT.length());
01003     raw_header[ARMA_MAT_TXT.length()] = '\0';
01004     
01005     const std::string header = raw_header.mem;
01006     
01007     if(ARMA_MAT_TXT == header.substr(0,ARMA_MAT_TXT.length()))
01008       {
01009       load_arma_ascii(x, name);
01010       }
01011     else
01012     if(ARMA_MAT_BIN == header.substr(0,ARMA_MAT_BIN.length()))
01013       {
01014       load_arma_binary(x, name);
01015       }
01016     else
01017     if(P5 == header.substr(0,P5.length()))
01018       {
01019       load_pgm_binary(x, name);
01020       }
01021     else
01022       {
01023       load_raw_ascii(x, name);
01024       }
01025     
01026     f.close();
01027     }
01028   
01029   }

template<typename T1 >
void diskio::save_field_arma_binary ( const field< T1 > &  x,
const std::string &  name 
) [inline, static, inherited]

Definition at line 1036 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().

01037   {
01038   arma_extra_debug_sigprint();
01039   
01040   arma_type_check<is_Mat<T1>::value == false>::apply();
01041   
01042   const std::string tmp_name = diskio::gen_tmp_name(final_name);
01043   std::ofstream f( tmp_name.c_str(), std::fstream::binary );
01044   
01045   if(f.is_open() == false)
01046     {
01047     arma_print("couldn't write ", tmp_name);
01048     }
01049   else
01050     {
01051     f << "ARMA_FLD_BIN" << '\n';
01052     f << x.n_rows << '\n';
01053     f << x.n_cols << '\n';
01054     
01055     for(u32 i=0; i<x.n_elem; ++i)
01056       {
01057       diskio::save_arma_binary(x[i], tmp_name, f);
01058       }
01059     
01060     const bool writing_problem = (f.good() == false);
01061     
01062     arma_warn(writing_problem, "trouble writing ", tmp_name );
01063     
01064     f.flush();
01065     f.close();
01066     
01067     if(writing_problem == false)
01068       {
01069       diskio::safe_rename(tmp_name, final_name);
01070       }
01071     
01072     }
01073   
01074   }

template<typename T1 >
void diskio::load_field_arma_binary ( field< T1 > &  x,
const std::string &  name 
) [inline, static, inherited]

Definition at line 1081 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().

01082   {
01083   arma_extra_debug_sigprint();
01084   
01085   arma_type_check<is_Mat<T1>::value == false>::apply();
01086   
01087   bool load_okay = true;
01088   
01089   std::ifstream f( name.c_str() );
01090   
01091   if(f.fail())
01092     {
01093     load_okay = false;
01094     arma_extra_debug_print("unable to read ", name);
01095     }
01096   else
01097     {
01098     std::string f_type;
01099     f >> f_type;
01100     
01101     if(f_type != "ARMA_FLD_BIN")
01102       {
01103       arma_print("unsupported field type in ", name);
01104       load_okay = false;
01105       }
01106     else
01107       {
01108       u32 f_n_rows;
01109       u32 f_n_cols;
01110     
01111       f >> f_n_rows;
01112       f >> f_n_cols;
01113       
01114       x.set_size(f_n_rows, f_n_cols);
01115       
01116       f.get();      
01117       
01118       for(u32 i=0; i<x.n_elem; ++i)
01119         {
01120         diskio::load_arma_binary(x[i], name, f);
01121         
01122         if(f.good() == false)
01123           {
01124           arma_print("trouble reading ", name);
01125           load_okay = false;
01126           break;
01127           }
01128         }
01129       }
01130     }
01131   
01132   f.close();
01133   
01134   
01135   if(load_okay == false)
01136     {
01137     x.reset();
01138     }
01139   }

template<typename T1 >
void diskio::save_field_ppm_binary ( const field< T1 > &  x,
const std::string &  final_name 
) [inline, static, inherited]

Definition at line 1146 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().

01147   {
01148   arma_extra_debug_sigprint();
01149   
01150   arma_type_check<is_Mat<T1>::value == false>::apply();
01151   typedef typename T1::elem_type eT;
01152   
01153   arma_debug_check( (x.n_elem != 3), "diskio::save_field_ppm_binary(): given field must have exactly 3 matrices of equal size" );
01154   
01155   bool same_size = true;
01156   for(u32 i=1; i<3; ++i)
01157     {
01158     if( (x(0).n_rows != x(i).n_rows) || (x(0).n_cols != x(i).n_cols) )
01159       {
01160       same_size = false;
01161       break;
01162       }
01163     }
01164   
01165   arma_debug_check( (same_size != true), "diskio::save_field_ppm_binary(): given field must have exactly 3 matrices of equal size" );
01166   
01167   const Mat<eT>& R = x(0);
01168   const Mat<eT>& G = x(1);
01169   const Mat<eT>& B = x(2);
01170   
01171   const std::string tmp_name = diskio::gen_tmp_name(final_name);
01172   std::ofstream f( tmp_name.c_str(), std::fstream::binary );
01173   
01174   if(f.is_open() == false)
01175     {
01176     arma_print("couldn't write ", tmp_name);
01177     }
01178   else
01179     {
01180     f << "P6" << '\n';
01181     f << R.n_cols << '\n';
01182     f << R.n_rows << '\n';
01183     f << 255 << '\n';
01184 
01185     const u32 n_elem = 3 * R.n_rows * R.n_cols;
01186     podarray<u8> tmp(n_elem);
01187 
01188     u32 i = 0;
01189     for(u32 row=0; row < R.n_rows; ++row)
01190       {
01191       for(u32 col=0; col < R.n_cols; ++col)
01192         {
01193         tmp[i+0] = u8( R.at(row,col) );
01194         tmp[i+1] = u8( G.at(row,col) );
01195         tmp[i+2] = u8( B.at(row,col) );
01196         
01197         i+=3;
01198         }
01199       }
01200     
01201     f.write(reinterpret_cast<const char*>(tmp.mem), n_elem);
01202     
01203     const bool writing_problem = (f.good() == false);
01204     
01205     arma_warn(writing_problem, "trouble writing ", tmp_name );
01206     
01207     f.flush();
01208     f.close();
01209     
01210     if(writing_problem == false)
01211       {
01212       diskio::safe_rename(tmp_name, final_name);
01213       }
01214     
01215     }
01216   
01217   }

template<typename T1 >
void diskio::load_field_ppm_binary ( field< T1 > &  x,
const std::string &  final_name 
) [inline, static, inherited]

Definition at line 1224 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().

01225   {
01226   arma_extra_debug_sigprint();
01227   
01228   arma_type_check<is_Mat<T1>::value == false>::apply();
01229   typedef typename T1::elem_type eT;
01230   
01231   std::fstream f;
01232   f.open(name.c_str(), std::fstream::in | std::fstream::binary);
01233   
01234   bool load_okay = true;
01235   
01236   if(f.is_open() == false)
01237     {
01238     load_okay = false;
01239     arma_extra_debug_print("unable to read ", name);
01240     }
01241   else
01242     {
01243     std::string f_header;
01244     f >> f_header;
01245     
01246     if(f_header == "P6")
01247       {
01248       u32 f_n_rows = 0;
01249       u32 f_n_cols = 0;
01250       int f_maxval = 0;
01251     
01252       diskio::pnm_skip_comments(f);
01253     
01254       f >> f_n_cols;
01255       diskio::pnm_skip_comments(f);
01256     
01257       f >> f_n_rows;
01258       diskio::pnm_skip_comments(f);
01259     
01260       f >> f_maxval;
01261       f.get();
01262       
01263       if( (f_maxval > 0) || (f_maxval <= 65535) )
01264         {
01265         x.set_size(3);
01266         Mat<eT>& R = x(0);
01267         Mat<eT>& G = x(1);
01268         Mat<eT>& B = x(2);
01269         
01270         R.set_size(f_n_rows,f_n_cols);
01271         G.set_size(f_n_rows,f_n_cols);
01272         B.set_size(f_n_rows,f_n_cols);
01273         
01274         if(f_maxval <= 255)
01275           {
01276           const u32 n_elem = 3*f_n_cols*f_n_rows;
01277           podarray<u8> tmp(n_elem);
01278           
01279           f.read( reinterpret_cast<char*>(tmp.memptr()), n_elem);
01280           
01281           u32 i = 0;
01282           
01283           //cout << "f_n_cols = " << f_n_cols << endl;
01284           //cout << "f_n_rows = " << f_n_rows << endl;
01285           
01286           
01287           for(u32 row=0; row < f_n_rows; ++row)
01288             {
01289             for(u32 col=0; col < f_n_cols; ++col)
01290               {
01291               R.at(row,col) = eT(tmp[i+0]);
01292               G.at(row,col) = eT(tmp[i+1]);
01293               B.at(row,col) = eT(tmp[i+2]);
01294               i+=3;
01295               }
01296             
01297             }
01298           }
01299         else
01300           {
01301           const u32 n_elem = 3*f_n_cols*f_n_rows;
01302           podarray<u16> tmp(n_elem);
01303           
01304           f.read( reinterpret_cast<char *>(tmp.memptr()), 2*n_elem);
01305           
01306           u32 i = 0;
01307           
01308           for(u32 row=0; row < f_n_rows; ++row)
01309             {
01310             for(u32 col=0; col < f_n_cols; ++col)
01311               {
01312               R.at(row,col) = eT(tmp[i+0]);
01313               G.at(row,col) = eT(tmp[i+1]);
01314               B.at(row,col) = eT(tmp[i+2]);
01315               i+=3;
01316               }
01317             
01318             }
01319           
01320           }
01321         
01322         }
01323       
01324       if(f.good() == false)
01325         {
01326         arma_print("trouble reading ", name);
01327         load_okay = false;
01328         }
01329       
01330       }
01331     else
01332       {
01333       arma_print("unsupported header in ", name);
01334       load_okay = false;
01335       }
01336     
01337     f.close();
01338     }
01339   
01340   
01341   if(load_okay == false)
01342     {
01343     x.reset();
01344     }
01345   
01346   }

void diskio::save_field_std_string ( const field< std::string > &  x,
const std::string &  name 
) [inline, static, inherited]

Definition at line 1352 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().

01353   {
01354   arma_extra_debug_sigprint();
01355   
01356   const std::string tmp_name = diskio::gen_tmp_name(final_name);
01357   std::ofstream f( tmp_name.c_str(), std::fstream::binary );
01358   
01359   if(f.is_open() == false)
01360     {
01361     arma_print("couldn't write ", tmp_name);
01362     }
01363   else
01364     {
01365     for(u32 row=0; row<x.n_rows; ++row)
01366     for(u32 col=0; col<x.n_cols; ++col)
01367       {
01368       f << x.at(row,col);
01369       
01370       if(col < x.n_cols-1)
01371         {
01372         f << ' ';
01373         }
01374       else
01375         {
01376         f << '\n';
01377         }
01378       }
01379     
01380     const bool writing_problem = (f.good() == false);
01381     
01382     arma_warn(writing_problem, "trouble writing ", tmp_name );
01383     
01384     f.flush();
01385     f.close();
01386     
01387     if(writing_problem == false)
01388       {
01389       diskio::safe_rename(tmp_name, final_name);
01390       }
01391     
01392     }
01393   
01394   }

void diskio::load_field_std_string ( field< std::string > &  x,
const std::string &  name 
) [inline, static, inherited]

Definition at line 1400 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().

01401   {
01402   arma_extra_debug_sigprint();
01403   
01404   bool load_okay = true;
01405   
01406   std::ifstream f( name.c_str() );
01407   
01408   if(f.fail())
01409     {
01410     load_okay = false;
01411     arma_extra_debug_print("unable to read ", name);
01412     }
01413   else
01414     {
01415     //
01416     // work out the size
01417     
01418     u32 f_n_rows = 0;
01419     u32 f_n_cols = 0;
01420     
01421     bool f_n_cols_found = false;
01422     
01423     std::string line_string;
01424     std::string token;
01425     
01426     while( (f.good() == true) && (load_okay == true) )
01427       {
01428       std::getline(f, line_string);
01429       if(line_string.size() == 0)
01430         break;
01431       
01432       std::stringstream line_stream(line_string);
01433       
01434       u32 line_n_cols = 0;
01435       while (line_stream >> token)
01436         line_n_cols++;
01437       
01438       if(f_n_cols_found == false)
01439         {
01440         f_n_cols = line_n_cols;
01441         f_n_cols_found = true;
01442         }
01443       else
01444         {
01445         if(line_n_cols != f_n_cols)
01446           {
01447           load_okay = false;
01448           arma_print("inconsistent number of columns in ", name );
01449           }
01450         }
01451       
01452       ++f_n_rows;
01453       }
01454       
01455     if(load_okay == true)
01456       {
01457       f.clear();
01458       f.seekg(0, ios::beg);
01459       //f.seekg(start);
01460       
01461       x.set_size(f_n_rows, f_n_cols);
01462     
01463       for(u32 row=0; row < x.n_rows; ++row)
01464         {
01465         for(u32 col=0; col < x.n_cols; ++col)
01466           {
01467           f >> x.at(row,col);
01468           }
01469         }
01470       }
01471     
01472     if(f.good() == false)
01473       {
01474       load_okay = false; 
01475       arma_print("trouble reading ", name );
01476       }
01477     
01478     f.close();
01479     }
01480   
01481   
01482   if(load_okay == false)
01483     {
01484     x.reset();
01485     }
01486   
01487   }

template<typename T1 >
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 1495 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().

01496   {
01497   arma_extra_debug_sigprint();
01498   
01499   arma_type_check<is_Mat<T1>::value == false>::apply();
01500   
01501   static const std::string ARMA_FLD_BIN = "ARMA_FLD_BIN";
01502   static const std::string           P6 = "P6";
01503   
01504   std::fstream f;
01505   f.open(name.c_str(), std::fstream::in | std::fstream::binary);
01506   
01507   if(f.is_open() == false)
01508     {
01509     x.reset();
01510     arma_extra_debug_print("unable to read ", name);
01511     }
01512   else
01513     {
01514     podarray<char> raw_header(ARMA_FLD_BIN.length() + 1);
01515     
01516     f.read(raw_header.memptr(), ARMA_FLD_BIN.length());
01517     raw_header[ARMA_FLD_BIN.length()] = '\0';
01518     
01519     const std::string header = raw_header.mem;
01520     
01521     if(ARMA_FLD_BIN == header.substr(0,ARMA_FLD_BIN.length()))
01522       {
01523       load_field_arma_binary(x, name);
01524       }
01525     else
01526     if(P6 == header.substr(0,P6.length()))
01527       {
01528       load_field_ppm_binary(x, name);
01529       }
01530     else
01531       {
01532       arma_print("unsupported header in ", name);
01533       x.reset();
01534       }
01535     
01536     f.close();
01537     }
01538   
01539   }