/home/rex/ebltrunk/core/libidx/include/idxIO.h

/***************************************************************************
 *   Copyright (C) 2008 by Pierre Sermanet *
 *   pierre.sermanet@gmail.com   *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef IDXIO_H_
#define IDXIO_H_

#include "idx.h"

#ifndef __NOSTL__
#include <iterator>
#include <iostream>
#include <fstream>
using namespace std;
#endif

// DUMPING /////////////////////////////////////////////////////////////////////

/* #ifdef __DUMP_STATES__ */

#ifdef __ANDROID__
#define DUMP_ROOT "/sdcard/"
#else
#define DUMP_ROOT "dump/";
#endif

extern uint dump_count;
extern std::string dump_prefix;

#define INIT_DUMP()                             \
    uint dump_count = 0;                        \
    std::string dump_prefix;

#define RESET_DUMP() dump_count = 0;
#define DUMP_PREFIX(s) { dump_prefix.clear(); dump_prefix << s << "_"; }
#define DUMP(mat, fname) {                                              \
    std::string n = DUMP_ROOT;                                          \
    mkdir_full(n);                                                      \
    n << dump_prefix << (dump_count < 10? "00": (dump_count < 100? "0":"")) \
      << dump_count << "_" << fname << "_" << mat << ".mat";            \
    dump_count = dump_count + 1;                                        \
    if (save_matrix(mat, n))                                            \
      cout << "Dumped " << n << " (min " << idx_min(mat)                \
           << " max " << idx_max(mat) << " mean " << idx_mean(mat)      \
           << ")" <<endl;                                               \
    else                                                                \
      cerr << "Failed to dump " << n << endl;                           \
  }

/* #else */
/* #define DUMP(mat, fname) */
/* #endif /\* DUMP_STATES *\/ */

// standard lush magic numbers
#define MAGIC_FLOAT_MATRIX      0x1e3d4c51
#define MAGIC_PACKED_MATRIX     0x1e3d4c52
#define MAGIC_DOUBLE_MATRIX     0x1e3d4c53
#define MAGIC_INTEGER_MATRIX    0x1e3d4c54
#define MAGIC_BYTE_MATRIX       0x1e3d4c55
#define MAGIC_SHORT_MATRIX      0x1e3d4c56
#define MAGIC_SHORT8_MATRIX     0x1e3d4c57
#define MAGIC_LONG_MATRIX       0x1e3d4c58
#define MAGIC_ASCII_MATRIX      0x2e4d4154

// non-standard magic numbers
#define MAGIC_UINT_MATRIX       0x1e3d4c59
#define MAGIC_UINT64_MATRIX     0x1e3d4c5a
#define MAGIC_INT64_MATRIX      0x1e3d4c5b

// pascal vincent's magic numbers
#define MAGIC_UBYTE_VINCENT     0x0800
#define MAGIC_BYTE_VINCENT      0x0900
#define MAGIC_SHORT_VINCENT     0x0B00
#define MAGIC_INT_VINCENT       0x0C00
#define MAGIC_FLOAT_VINCENT     0x0D00
#define MAGIC_DOUBLE_VINCENT    0x0E00

namespace ebl {
  
  // TODO: implement all types.
  // TODO: is check for endianess required?

  // loading
  
  template <typename T>
    idx<T> load_matrix(const char *filename);
  template <typename T>
    idx<T> load_matrix(const std::string &filename);
  template <typename T>
    void load_matrix(idx<T>& m, const char *filename);
  template <typename T>
    void load_matrix(idx<T>& m, const std::string &filename);
  template <typename T>
    idx<T> load_matrix(FILE *fp, idx<T> *out);
  template <typename T>
    midx<T> load_matrices(const std::string &filename, bool ondemand = true);
  
  // saving
  
  template <typename T>
    bool save_matrix(idx<T>& m, const std::string &filename);
  template <typename T2, typename T>
    bool save_matrix(idx<T>& m, const std::string &filename);
  template <typename T>
    bool save_matrix(idx<T>& m, const char *filename);
  template <typename T>
    bool save_matrix(idx<T>& m, FILE *fp);
  template <typename T>
    bool save_matrices(midx<T>& m, const std::string &filename);
  template <typename T>
    bool save_matrices_individually(midx<T>& m, const std::string &root,
                                    bool print = false);
  template <typename T>
    bool save_matrices(midx<T>& m1, midx<T> &m2, const std::string &filename);
  template <typename T>
    bool save_matrices(std::list<std::string> &filenames,
                       const std::string &filename);
  template <typename T>
    bool save_matrix(std::list<std::string> &filenames,
                     const std::string &filename);

  // helper functions
  
  EXPORT int get_matrix_type(const char *filename, std::string &type);
  EXPORT int get_matrix_type(const char *filename);
  EXPORT bool is_matrix(const char *filename);
  EXPORT bool is_magic_vincent(int magic);
  EXPORT bool is_magic(int magic);
  EXPORT idxdim get_matrix_dims(const char *filename);
  EXPORT idxdim read_matrix_header(FILE *fp, int &magic);
  EXPORT bool has_multiple_matrices(const char *filename);

} // end namespace ebl

#include "idxIO.hpp"

#endif /* IDXIO_H_ */