MWAWPictBitmap.hxx

Go to the documentation of this file.

/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libmwaw
* Version: MPL 2.0 / LGPLv2+
*
* The contents of this file are subject to the Mozilla Public License Version
* 2.0 (the "License"); you may not use this file except in compliance with
* the License or as specified alternatively below. You may obtain a copy of
* the License at http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* Major Contributor(s):
* Copyright (C) 2002 William Lachance (wrlach@gmail.com)
* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)
* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)
* Copyright (C) 2006, 2007 Andrew Ziem
* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)
*
*
* All Rights Reserved.
*
* For minor contributions see the git repository.
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),
* in which case the provisions of the LGPLv2+ are applicable
* instead of those above.
*/

/* This header contains code specific to some bitmap
 */

#ifndef MWAW_PICT_BITMAP
#  define MWAW_PICT_BITMAP

#include <assert.h>

#include <vector>

#include "libmwaw_internal.hxx"
#include "MWAWDebug.hxx"
#include "MWAWPict.hxx"

//
//   Some container
//

template <class T> class MWAWPictBitmapContainer
{
public:
  MWAWPictBitmapContainer(MWAWVec2i const &sz) : m_size(sz), m_data(0L)
  {
    if (m_size[0]*m_size[1] == 0) return;
    m_data = new T[size_t(m_size[0]*m_size[1])];
    std::uninitialized_fill_n(m_data, m_size[0] * m_size[1], T());
  }
  virtual ~MWAWPictBitmapContainer()
  {
    if (m_data) delete [] m_data;
  }

  bool ok() const
  {
    return (m_data != 0L);
  }

  int cmp(MWAWPictBitmapContainer<T> const &orig) const
  {
    int diff = m_size.cmpY(orig.m_size);
    if (diff) return diff;
    if (!m_data) return orig.m_data ? 1 : 0;
    if (!orig.m_data) return -1;
    for (int i=0; i < m_size[0]*m_size[1]; i++) {
      if (m_data[i] < orig.m_data[i]) return -1;
      if (m_data[i] > orig.m_data[i]) return 1;
    }
    return 0;
  }
  MWAWVec2i const &size() const
  {
    return m_size;
  }
  int numRows() const
  {
    return m_size[0];
  }
  int numColumns() const
  {
    return m_size[1];
  }

  T const &get(int i, int j) const
  {
    if (m_data == 0L || i<0 || i >= m_size[0] || j<0 || j >= m_size[1])
      throw libmwaw::GenericException();
    return m_data[i+m_size[0]*j];
  }
  T const *getRow(int j) const
  {
    if (m_data == 0L || j<0 || j >= m_size[1])
      throw libmwaw::GenericException();
    return m_data+m_size[0]*j;
  }

  void set(int i, int j, T const &v)
  {
    if (m_data == 0L || i<0 || i >= m_size[0] || j<0 || j >= m_size[1]) {
      MWAW_DEBUG_MSG(("MWAWPictBitmapContainer::set: call with bad coordinate %d %d\n", i, j));
      return;
    }
    m_data[i+j*m_size[0]] = v;
  }

  template <class U>
  void setRow(int j, U const *val)
  {
    if (m_data == 0L || j<0 || j >= m_size[1]) {
      MWAW_DEBUG_MSG(("MWAWPictBitmapContainer::setRow: call with bad coordinate %d\n", j));
      return;
    }
    for (int i = 0, ind=j*m_size[0]; i < m_size[0]; i++, ind++) m_data[ind] = T(val[i]);
  }

  template <class U>
  void setColumn(int i, U const *val)
  {
    if (m_data == 0L || i<0 || i >= m_size[0]) {
      MWAW_DEBUG_MSG(("MWAWPictBitmapContainer::setColumn: call with bad coordinate %d\n", i));
      return;
    }
    for (int j = 0, ind=i; j < m_size[1]; j++, ind+=m_size[0]) m_data[ind] = T(val[i]);
  }

private:
  MWAWPictBitmapContainer(MWAWPictBitmapContainer const &orig);
  MWAWPictBitmapContainer &operator=(MWAWPictBitmapContainer const &orig);
protected:
  MWAWVec2i m_size;
  T *m_data;
};

class MWAWPictBitmapContainerBool : public MWAWPictBitmapContainer<bool>
{
public:
  MWAWPictBitmapContainerBool(MWAWVec2i const &sz) : MWAWPictBitmapContainer<bool>(sz) {}

  int cmp(MWAWPictBitmapContainerBool const &orig) const
  {
    int diff = m_size.cmpY(orig.m_size);
    if (diff) return diff;
    if (!m_data) return orig.m_data ? 1 : 0;
    if (!orig.m_data) return -1;
    for (int i=0; i < m_size[0]*m_size[1]; i++) {
      if (m_data[i] == orig.m_data[i]) continue;
      return m_data[i] ? 1 : -1;
    }
    return 0;
  }

  void setRowPacked(int j, unsigned char const *val)
  {
    if (m_data == 0L || j<0 || j >= m_size[1]) {
      MWAW_DEBUG_MSG(("MWAWPictBitmapContainerBool::setRowPacked: call with bad coordinate %d\n", j));
      return;
    }
    for (int i = 0, ind = j*m_size[0]; i < m_size[0];) {
      unsigned char v = *(val++);
      unsigned char mask = 0x80;
      for (int p = 0; p < 8 && i < m_size[0]; i++, p++, ind++) {
        m_data[ind] = ((v&mask) != 0);
        mask = (unsigned char)(mask >> 1);
      }
    }
  }
};

class MWAWPictBitmap : public MWAWPict
{
public:
  enum SubType { BW, Indexed, Color };
  virtual Type getType() const
  {
    return MWAWPict::Bitmap;
  }
  virtual SubType getSubType() const = 0;

  virtual bool getBinary(librevenge::RVNGBinaryData &res, std::string &s) const
  {
    if (!valid()) return false;

    s = "image/pict";
    createFileData(res);
    return true;
  }

  virtual bool valid() const
  {
    return false;
  }

  virtual int cmp(MWAWPict const &a) const
  {
    int diff = MWAWPict::cmp(a);
    if (diff) return diff;
    MWAWPictBitmap const &aPict = static_cast<MWAWPictBitmap const &>(a);

    // the type
    diff = getSubType() - aPict.getSubType();
    if (diff) return (diff < 0) ? -1 : 1;

    return 0;
  }

protected:
  virtual bool createFileData(librevenge::RVNGBinaryData &result) const = 0;

  MWAWPictBitmap(MWAWVec2i const &sz)
  {
    setBdBox(MWAWBox2f(MWAWVec2f(0,0), sz));
  }
};

class MWAWPictBitmapBW : public MWAWPictBitmap
{
public:
  virtual SubType getSubType() const
  {
    return BW;
  }

  virtual int cmp(MWAWPict const &a) const
  {
    int diff = MWAWPictBitmap::cmp(a);
    if (diff) return diff;
    MWAWPictBitmapBW const &aPict = static_cast<MWAWPictBitmapBW const &>(a);

    return m_data.cmp(aPict.m_data);
  }

  virtual bool valid() const
  {
    return m_data.ok();
  }

  MWAWPictBitmapBW(MWAWVec2i const &sz) : MWAWPictBitmap(sz), m_data(sz) { }

  MWAWVec2i const &size() const
  {
    return m_data.size();
  }
  int numRows() const
  {
    return m_data.numRows();
  }
  int numColumns() const
  {
    return m_data.numColumns();
  }
  bool get(int i, int j) const
  {
    return m_data.get(i,j);
  }
  bool const *getRow(int j) const
  {
    return m_data.getRow(j);
  }
  void set(int i, int j, bool v)
  {
    m_data.set(i,j, v);
  }
  void setRow(int j, bool const *val)
  {
    m_data.setRow(j, val);
  }
  void setRowPacked(int j, unsigned char const *val)
  {
    m_data.setRowPacked(j, val);
  }
  void setColumn(int i, bool const *val)
  {
    m_data.setColumn(i, val);
  }

protected:
  virtual bool createFileData(librevenge::RVNGBinaryData &result) const;

  MWAWPictBitmapContainerBool m_data;
};

class MWAWPictBitmapIndexed : public MWAWPictBitmap
{
public:
  virtual SubType getSubType() const
  {
    return Indexed;
  }

  virtual int cmp(MWAWPict const &a) const
  {
    int diff = MWAWPictBitmap::cmp(a);
    if (diff) return diff;
    MWAWPictBitmapIndexed const &aPict = static_cast<MWAWPictBitmapIndexed const &>(a);

    diff=int(m_colors.size())-int(aPict.m_colors.size());
    if (diff) return (diff < 0) ? -1 : 1;
    for (size_t c=0; c < m_colors.size(); c++) {
      if (m_colors[c] < aPict.m_colors[c])
        return 1;
      if (m_colors[c] > aPict.m_colors[c])
        return -1;
    }
    return m_data.cmp(aPict.m_data);
  }

  virtual bool valid() const
  {
    return m_data.ok();
  }

  MWAWPictBitmapIndexed(MWAWVec2i const &sz) : MWAWPictBitmap(sz), m_data(sz), m_colors() { }

  MWAWVec2i const &size() const
  {
    return m_data.size();
  }
  int numRows() const
  {
    return m_data.numRows();
  }
  int numColumns() const
  {
    return m_data.numColumns();
  }
  int get(int i, int j) const
  {
    return m_data.get(i,j);
  }
  int const *getRow(int j) const
  {
    return m_data.getRow(j);
  }

  void set(int i, int j, int v)
  {
    m_data.set(i,j, v);
  }
  template <class U> void setRow(int j, U const *val)
  {
    m_data.setRow(j, val);
  }
  template <class U> void setColumn(int i, U const *val)
  {
    m_data.setColumn(i, val);
  }

  std::vector<MWAWColor> const &getColors() const
  {
    return m_colors;
  }
  void setColors(std::vector<MWAWColor> const &cols)
  {
    m_colors = cols;
  }

protected:
  virtual bool createFileData(librevenge::RVNGBinaryData &result) const;

  MWAWPictBitmapContainer<int> m_data;
  std::vector<MWAWColor> m_colors;
};

class MWAWPictBitmapColor : public MWAWPictBitmap
{
public:
  virtual SubType getSubType() const
  {
    return Indexed;
  }

  virtual int cmp(MWAWPict const &a) const
  {
    int diff = MWAWPictBitmap::cmp(a);
    if (diff) return diff;
    MWAWPictBitmapColor const &aPict = static_cast<MWAWPictBitmapColor const &>(a);

    return m_data.cmp(aPict.m_data);
  }

  virtual bool valid() const
  {
    return m_data.ok();
  }

  MWAWPictBitmapColor(MWAWVec2i const &sz, bool useAlphaChannel=false) : MWAWPictBitmap(sz), m_data(sz), m_hasAlpha(useAlphaChannel) { }

  MWAWVec2i const &size() const
  {
    return m_data.size();
  }
  int numRows() const
  {
    return m_data.numRows();
  }
  int numColumns() const
  {
    return m_data.numColumns();
  }
  MWAWColor get(int i, int j) const
  {
    return m_data.get(i,j);
  }
  MWAWColor const *getRow(int j) const
  {
    return m_data.getRow(j);
  }

  void set(int i, int j, MWAWColor const &v)
  {
    m_data.set(i,j, v);
  }
  void setRow(int j, MWAWColor const *val)
  {
    m_data.setRow(j, val);
  }
  void setColumn(int i, MWAWColor const *val)
  {
    m_data.setColumn(i, val);
  }

protected:
  virtual bool createFileData(librevenge::RVNGBinaryData &result) const;

  MWAWPictBitmapContainer<MWAWColor> m_data;

  bool m_hasAlpha;
};
#endif
// vim: set filetype=cpp tabstop=2 shiftwidth=2 cindent autoindent smartindent noexpandtab: