@hxa-rn/react-native-gcanvas 6.0.24-beta.1

package/harmony/gcanvas/src/main/cpp/core/src/platform/Linux/PortableMap.hpp

@@ -0,0 +1,621 @@
+/**
+ * Portable Anymap Format Utility.
+ *
+ * Utility for loading and saving Portable Anymap Format (PNM) file,
+ * including PBM, PGM and PPM file (both in ascii and binary):
+ * * PBM (Portable BitMap Format)
+ * * PGM (Portable GreyMap Format)
+ * * PPM (Portable PixMap Format)
+ *
+ * @author Chaoya Li <harry75369@gmail.com>
+ * @date   May 2013
+ * @see    http://en.wikipedia.org/wiki/Netpbm_format
+ * @see    http://www.fileformat.info/format/pbm/spec/index.htm
+ * @todo   support for wider bytes in binary format
+ */
+#ifndef __PORTABLE_MAP_HPP___
+#define __PORTABLE_MAP_HPP___
+
+#include <errno.h>
+#include <sstream>
+#include <stdio.h>
+#include <string.h>
+
+#include "utils.hpp"
+
+class PortableMap {
+public:
+  typedef size_t SizeType;
+  enum MAGIC_NUMBER {
+    NONE = 0,
+    P1, ///< ascii  PBM
+    P2, ///< ascii  PGM
+    P3, ///< ascii  PPM
+    P4, ///< binary PBM
+    P5, ///< binary PGM
+    P6  ///< binary PPM
+  };
+  static inline const std::string &getID(SizeType i) {
+    const static std::string ids[7] = {"NONE", "P1", "P2", "P3",
+                                       "P4",   "P5", "P6"};
+    return ids[i];
+  }
+  static const int LENGTH_LIMIT = 70;
+  inline bool isPBM() const { return (_identifier == P1 || _identifier == P4); }
+  inline bool isPGM() const { return (_identifier == P2 || _identifier == P5); }
+  inline bool isPPM() const { return (_identifier == P3 || _identifier == P6); }
+
+public:
+  /** PortableMap constructor */
+  PortableMap() : _binary(0), _ascii(0) {}
+  /** PortableMap copy-constructor */
+  PortableMap(const PortableMap &other) {
+    _identifier = other._identifier;
+    _width = other._width;
+    _height = other._height;
+    _maxVal = other._maxVal;
+    _filename = other._filename;
+    _binary = 0;
+    _ascii = 0;
+    if (other._binary) {
+      SizeType binarySize = getBinarySize();
+      reAllocBinary(binarySize);
+      ASSERT(_binary);
+      if (0 == memcpy(_binary, other._binary, binarySize)) {
+        WARN("binary data copy failed!");
+      }
+    }
+    if (other._ascii) {
+      SizeType asciiSize = getAsciiSize();
+      reAllocAscii(asciiSize);
+      ASSERT(_ascii);
+      if (0 == memcpy(_ascii, other._ascii, asciiSize)) {
+        WARN("ascii data copy failed!");
+      }
+    }
+  }
+  /** PortableMap deconstructor */
+  virtual ~PortableMap() { clean(); }
+  /** PortableMap assigenment operator */
+  PortableMap &operator=(const PortableMap &other) {
+    _identifier = other._identifier;
+    _width = other._width;
+    _height = other._height;
+    _maxVal = other._maxVal;
+    _filename = other._filename;
+    _binary = 0;
+    _ascii = 0;
+    if (other._binary) {
+      SizeType binarySize = getBinarySize();
+      reAllocBinary(binarySize);
+      ASSERT(_binary);
+      if (0 == memcpy(_binary, other._binary, binarySize)) {
+        WARN("binary data copy failed!");
+      }
+    }
+    if (other._ascii) {
+      SizeType asciiSize = getAsciiSize();
+      reAllocAscii(asciiSize);
+      ASSERT(_ascii);
+      if (0 == memcpy(_ascii, other._ascii, asciiSize)) {
+        WARN("ascii data copy failed!");
+      }
+    }
+    return *this;
+  }
+
+  /* piles of getters */
+  inline const MAGIC_NUMBER &getIdentifier() const { return _identifier; }
+  inline const SizeType &getWidth() const { return _width; }
+  inline const SizeType &getHeight() const { return _height; }
+  inline const SizeType &getMaxValue() const { return _maxVal; }
+  inline const std::string &getFilename() const { return _filename; }
+  inline MAGIC_NUMBER &identifier() { return _identifier; }
+  inline SizeType &width() { return _width; }
+  inline SizeType &height() { return _height; }
+  inline SizeType &maxValue() { return _maxVal; }
+  inline std::string &filename() { return _filename; }
+  inline const unsigned char *getBinaryData() {
+    ASSERT(loaded());
+    if (!_binary) {
+      ascii2binary();
+    }
+    return _binary;
+  }
+  inline const SizeType *getAsciiData() {
+    ASSERT(loaded());
+    if (!_ascii) {
+      binary2ascii();
+    }
+    return _ascii;
+  }
+
+  /* piles of setters */
+  inline void setIdentifier(MAGIC_NUMBER id) { _identifier = id; }
+  inline void setWidth(const SizeType &w) { _width = w; }
+  inline void setHeight(const SizeType &h) { _height = h; }
+  inline void setMaxValue(const SizeType &m) { _maxVal = m; }
+  inline void setFilename(const std::string &f) { _filename = f; }
+  inline void setBinaryData(unsigned char *b) { _binary = b; };
+  inline void setAsciiData(SizeType *a) { _ascii = a; }
+
+  /** load a portable map file.
+   *
+   * @param filename the name of the portable map file.
+   */
+  void load(const std::string &filename) {
+    // process filename
+    FILE *fp = fopen(filename.c_str(), "r");
+    if (!fp) {
+      WARN("File read failed: %s", strerror(errno));
+      return;
+    }
+    setFilename(filename);
+
+    // process magic number
+    MAGIC_NUMBER id = NONE;
+    std::string token = getNextToken(fp);
+    for (int i = 1; i <= 6; i++)
+      if (token == getID(i)) {
+        id = (MAGIC_NUMBER)i;
+        break;
+      }
+    if (id == NONE) {
+      WARN("Invalid magic number!");
+      fclose(fp);
+      return;
+    }
+    setIdentifier(id);
+
+    // process width and height
+    token = getNextToken(fp);
+    int w = str2int(token);
+    if (w <= 0) {
+      WARN("Invalid width!");
+      fclose(fp);
+      return;
+    }
+    setWidth(w);
+    token = getNextToken(fp);
+    int h = str2int(token);
+    if (h <= 0) {
+      WARN("Invalid height!");
+      fclose(fp);
+      return;
+    }
+    setHeight(h);
+
+    // process max value
+    if (_identifier == P1 || _identifier == P4) {
+      setMaxValue(1);
+    } else {
+      token = getNextToken(fp);
+      int m = str2int(token);
+      if (m <= 0) {
+        WARN("Invalid max value!");
+        fclose(fp);
+        return;
+      } else if (_identifier > P3 && m > 255) {
+        WARN("Invalid max value in binary file! (m=%d)", m);
+        fclose(fp);
+        return;
+      }
+      setMaxValue(m);
+    }
+    readMap(fp);
+    fclose(fp);
+
+    if (!_ascii && _binary) {
+      binary2ascii();
+    }
+    if (!_binary && _ascii) {
+      ascii2binary();
+    }
+  }
+
+  inline bool loaded() const {
+    if (_identifier != NONE && (_ascii || _binary)) {
+      return true;
+    }
+    return false;
+  }
+
+  /** write a binary portable map file.
+   *
+   * @param filename the name of the portable map file.
+   */
+  void writeBinary(const std::string &filename) {
+    if (_identifier < P4) // ascii format, need conversion
+    {
+      if (_maxVal > 255) {
+        WARN("Invalid max value in binary file! (m=%ld)", _maxVal);
+        return;
+      }
+      setIdentifier((MAGIC_NUMBER)((int)_identifier + 3));
+    }
+    write(filename);
+  }
+
+  /** write an ascii portable map file.
+   *
+   * @param filename the name of the portable map file.
+   */
+  void writeAscii(const std::string &filename) {
+    if (_identifier > P3) // binary format, need conversion
+    {
+      setIdentifier((MAGIC_NUMBER)((int)_identifier - 3));
+    }
+    write(filename);
+  }
+
+  /** print the map */
+  void print() {
+    printf("Magic number: %s\n", getID(_identifier).c_str());
+    printf("Width:        %ld\n", _width);
+    printf("Height:       %ld\n", _height);
+    printf("Max Value:    %ld\n", _maxVal);
+    printf("Binary Size:  %ld\n", getBinarySize());
+    printf("Ascii Size:   %ld\n", getAsciiSize());
+
+    if (!_ascii && _binary) {
+      binary2ascii();
+    } else if (!_ascii) {
+      WARN("no any data yet!");
+      return;
+    }
+    // SizeType t = getAsciiSize();
+    // SizeType width = _width;
+    // if ( _identifier == P3 || _identifier == P6 ) width *= 3;
+    // for ( SizeType i=0; i < t; i++ )
+    //{
+    // printf("%ld%c", _ascii[i], (((i+1)%width)?' ':'\n'));
+    //}
+  }
+
+private:
+  /** write a portable map file.
+   *
+   * @param filename the name of the portable map file.
+   */
+  void write(const std::string &filename) {
+    // open file to write
+    FILE *fp = fopen(filename.c_str(), "w");
+    if (!fp) {
+      WARN("File write failed: %s", strerror(errno));
+      return;
+    }
+
+    // write magic number
+    if (_identifier == NONE) {
+      WARN("None magic number set!");
+      fclose(fp);
+      return;
+    }
+    if (_identifier > P3 && _maxVal > 255) {
+      WARN("Max value greater than 255 in binary format!");
+      fclose(fp);
+      return;
+    }
+    fprintf(fp, "%s\n", getID(_identifier).c_str());
+
+    // write width and height
+    if (_width > 0 && _height > 0) {
+      fprintf(fp, "%ld %ld\n", _width, _height);
+    } else {
+      WARN("Invalid width or height! (width=%ld, height=%ld)", _width, _height);
+      fclose(fp);
+      return;
+    }
+
+    // write max value
+    if (_identifier != P1 && _identifier != P4 && _maxVal > 0) {
+      fprintf(fp, "%ld\n", _maxVal);
+    } else if (_maxVal <= 0) {
+      WARN("Invalid max value! (maxVal=%ld)", _maxVal);
+      fclose(fp);
+      return;
+    }
+    writeMap(fp);
+    fclose(fp);
+  }
+
+  void ascii2binary() {
+    ASSERT(_ascii);
+    SizeType binarySize = getBinarySize();
+    SizeType asciiSize = getAsciiSize();
+    reAllocBinary(binarySize); // assign binary data
+    if (_identifier == P1 || _identifier == P4) {
+      SizeType bc = 0;
+      for (SizeType j = 0; j < _height; j++)
+        for (SizeType i = 0; i < _width; i += 8) {
+          unsigned char c = 0;
+          for (SizeType k = 0; k < 8; k++) {
+            c = c << 1;
+            if (i + k < _width) {
+              c |= ((_ascii[j * _width + i + k]) ? 1 : 0);
+            }
+          }
+          _binary[bc++] = c;
+        }
+      ASSERT(bc == binarySize);
+    } else {
+      ASSERT(_maxVal < 256);
+      ASSERT(binarySize == asciiSize);
+      for (SizeType i = 0; i < asciiSize; i++)
+        _binary[i] = (unsigned char)_ascii[i];
+    }
+  }
+
+  void binary2ascii() {
+    ASSERT(_binary);
+    SizeType binarySize = getBinarySize();
+    SizeType asciiSize = getAsciiSize();
+    reAllocAscii(asciiSize); // alloc ascii data
+    if (_identifier == P1 || _identifier == P4) {
+      SizeType w = _width / 8 + ((_width % 8 == 0) ? 0 : 1);
+      for (SizeType j = 0; j < _height; j++)
+        for (SizeType i = 0; i < _width; i++) {
+          _ascii[j * _width + i] =
+              ((_binary[j * w + i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0);
+        }
+    } else {
+      ASSERT(binarySize == asciiSize);
+      for (SizeType i = 0; i < asciiSize; i++)
+        _ascii[i] = (SizeType)_binary[i];
+    }
+  }
+
+private:
+  /** eat white spaces in a file.
+   *
+   * @param fp reference to pointer to FILE.
+   */
+  static void eatWhitespaces(FILE *&fp) {
+    if (!fp) {
+      return;
+    }
+
+    // find a non-space character
+    char c;
+    do {
+      c = fgetc(fp);
+    } while (c != EOF && isspace(c));
+
+    // eat comments
+    while (c == '#') {
+      // to the end of the line
+      do {
+        c = fgetc(fp);
+      } while (c != EOF && c != '\n' && c != '\r');
+
+      // and find a non-space charecter again
+      while (c != EOF && isspace(c)) {
+        c = fgetc(fp);
+      }
+    }
+
+    // push the non-space character back for token reading
+    if (c != EOF) {
+      ASSERT_MSG(ungetc(c, fp) != EOF, "Unknown IO error!");
+    }
+  }
+
+  /** get next token in a file.
+   *
+   * @param fp reference to pointer to FILE.
+   * @param isP1 if true then read one character as a token.
+   * @return token as std::string.
+   */
+  static std::string getNextToken(FILE *&fp, bool isP1 = false) {
+    if (!fp) {
+      return "";
+    }
+
+    eatWhitespaces(fp);
+
+    std::ostringstream buf;
+    char c;
+    SizeType count = 0;
+    SizeType max = 0x7fffffff; // should be enough?
+    if (isP1) {
+      max = 1;
+    }
+    while (count < max && !isspace(c = fgetc(fp))) {
+      buf << c;
+      count++;
+    }
+    return buf.str();
+  }
+
+  /** convert string to integer.
+   *
+   * @param str string representation of a integer.
+   * @return corresponding integer if successfull, -1 otherwise.
+   */
+  static int str2int(const std::string &str) {
+    int result;
+    return (std::stringstream(str) >> result) ? result : -1;
+  }
+
+public:
+  /** find actual number of bytes for binary data.
+   *
+   * @return actual number of bytes.
+   */
+  SizeType getBinarySize() const {
+    ASSERT(_width > 0 && _height > 0);
+    SizeType n = _width * _height;
+    SizeType t = 0;
+    switch (_identifier) {
+    case P1:
+    case P4:
+      t = (_width / 8 + ((_width % 8 == 0) ? 0 : 1)) * _height;
+      break;
+    case P2:
+    case P5:
+      t = n;
+      break;
+    case P3:
+    case P6:
+      t = 3 * n;
+      break;
+    default:
+      ASSERT_MSG(false, "Error magic number!");
+    }
+    return t;
+  }
+
+  /** find actual number of values for ascii data.
+   *
+   * @return actual number of values.
+   */
+  SizeType getAsciiSize() const {
+    ASSERT(_width > 0 && _height > 0);
+    SizeType n = _width * _height;
+    SizeType t = n;
+    if (_identifier == P3 || _identifier == P6) {
+      t *= 3;
+    }
+    return t;
+  }
+
+private:
+  /** write map body to a file.
+   *
+   * @param fp reference to pointer to FILE.
+   */
+  void writeMap(FILE *&fp) {
+    ASSERT(_identifier != NONE);
+    if (_identifier > P3) // binary format
+    {
+      SizeType t = getBinarySize();
+      if (!_binary && _ascii) {
+        ascii2binary();
+      } else if (!_binary) {
+        WARN("no any data yet!");
+        return;
+      }
+      ASSERT(_binary);
+      fwrite(_binary, sizeof(unsigned char), t, fp);
+    } else // ascii format
+    {
+      SizeType t = getAsciiSize();
+      if (!_ascii && _binary) {
+        binary2ascii();
+      } else if (!_ascii) {
+        WARN("no any data yet!");
+        return;
+      }
+      ASSERT(_ascii);
+      int len = 0;
+      for (int i = 0; i < t; i++) {
+        int d = fprintf(fp, "%ld ", _ascii[i]);
+        len += d;
+        if (len > LENGTH_LIMIT) {
+          fprintf(fp, "\n");
+          len = 0;
+        }
+      }
+    }
+  }
+
+  /** read map body from a file.
+   *
+   * @param fp reference to pointer to FILE.
+   */
+  void readMap(FILE *&fp) {
+    ASSERT(_identifier != NONE);
+    if (_identifier > P3) // binary format
+    {
+      SizeType t = getBinarySize();
+      reAllocBinary(t);
+      ASSERT(_binary);
+      fread(_binary, sizeof(unsigned char), t, fp);
+    } else // ascii format
+    {
+      SizeType t = getAsciiSize();
+      reAllocAscii(t);
+      ASSERT(_ascii);
+      std::string token;
+      SizeType rT = 0;
+      while (rT != t) {
+        token = getNextToken(fp, _identifier == P1);
+        int v = str2int(token);
+        if (v < 0) {
+          WARN("Invalid pixel value! (%ld th value is %d)", rT, v);
+          return;
+        }
+        _ascii[rT] = (SizeType)v;
+        rT++;
+      }
+    }
+  }
+
+private:
+  /** Re-alloc memory for binary data */
+  inline void reAllocBinary(SizeType size) {
+    if (_binary) {
+      delete[] _binary;
+    }
+    _binary = new unsigned char[size];
+  }
+  /** Re-alloc memory for ascii data */
+  inline void reAllocAscii(SizeType size) {
+    if (_ascii) {
+      delete[] _ascii;
+    }
+    _ascii = new SizeType[size];
+  }
+  /** Clean allocated memories */
+  inline void clean() {
+    if (_binary) {
+      delete[] _binary;
+    }
+    if (_ascii) {
+      delete[] _ascii;
+    }
+  }
+
+private:
+  MAGIC_NUMBER _identifier;
+  SizeType _width;
+  SizeType _height;
+  SizeType _maxVal;
+  std::string _filename;
+  unsigned char *_binary; ///< binary data
+  SizeType *_ascii;       ///< ascii data
+};
+
+class PPMWriter {
+public:
+  PPMWriter(int w, int h) : m_width(w), m_height(h), m_data(nullptr) {
+    m_ppm.setIdentifier(PortableMap::P6);
+    m_ppm.setWidth(m_width);
+    m_ppm.setHeight(m_height);
+    m_ppm.setMaxValue(255);
+    m_data = new size_t[w * h * 3];
+    ASSERT(m_data);
+    m_ppm.setAsciiData(m_data);
+  }
+
+  ~PPMWriter() {
+    m_ppm.setAsciiData(0);
+    delete[] m_data;
+  }
+
+  void setPixel(int x, int y, double r, double g, double b) {
+    m_data[3 * (x + y * m_width) + 0] = (size_t)r;
+    m_data[3 * (x + y * m_width) + 1] = (size_t)g;
+    m_data[3 * (x + y * m_width) + 2] = (size_t)b;
+  }
+
+  void writeFile(const std::string &fp) { m_ppm.writeBinary(fp); }
+
+private:
+  PortableMap m_ppm;
+  int m_width;
+  int m_height;
+  size_t *m_data;
+};
+
+#endif //__PORTABLE_MAP_HPP__