DStructuringElement.h

/*
 * Copyright (c) 2011-2016, Matthieu FAESSEL and ARMINES
 * 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.
 *     * Neither the name of Matthieu FAESSEL, or ARMINES nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``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 COPYRIGHT HOLDERS AND CONTRIBUTORS 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 _STR_ELT_HPP
#define _STR_ELT_HPP
 
#include "Core/include/DCommon.h"
#include "Core/include/DBaseObject.h"
#include "Base/include/DImageDraw.h"
 
#include <string>
 
namespace smil
{
  enum seType {
    SE_Generic,
    SE_Hex,
    SE_Hex0,
    SE_Squ,
    SE_Squ0,
    SE_Cross,
    SE_Horiz,
    SE_Vert,
    SE_Line,
    SE_Cube,
    SE_Cross3D,
    SE_Line3D,
    SE_CenteredLine,
    SE_CenteredLine3D,
    SE_Rhombicuboctahedron
  };
 
  class StrElt : public BaseObject
  {
  public:
    StrElt(UINT s = 1)
        : BaseObject("StrElt"), odd(false), seT(SE_Generic), size(s)
    {
      this->setName();
    }
 
    StrElt(const StrElt &rhs) : BaseObject(rhs)
    {
      this->clone(rhs);
      this->setName();
    }
 
#ifndef SWIG
    /* Available only under C++ */
    StrElt(bool oddSE, UINT nbrPts, ...)
        : BaseObject("StrElt"), odd(oddSE), seT(SE_Generic), size(1)
    {
      UINT index;
      va_list vl;
      va_start(vl, nbrPts);
 
      for (UINT i = 0; i < nbrPts; i++) {
        index = va_arg(vl, UINT);
        addPoint(index);
      }
      this->setName();
    }
#endif // SWIG
 
    StrElt(bool oddSE, vector<UINT> indexList)
        : BaseObject("StrElt"), odd(oddSE), seT(SE_Generic), size(1)
    {
      vector<UINT>::iterator it;
      for (it = indexList.begin(); it != indexList.end(); it++)
        addPoint(*it);
      this->setName();
    }
 
    ~StrElt()
    {
    }
    IntPoint getPoint(const UINT i)
    {
      return points[i];
    }
 
    UINT getSize() const
    {
      return size;
    }
 
    StrElt &operator=(const StrElt &rhs);
 
    void clone(const StrElt &rhs);
 
    vector<IntPoint> points;
 
    void addPoint(const UINT index);
 
    void addPoint(int x, int y, int z = 0);
 
    void addPoint(const IntPoint &pt);
 
    const StrElt operator()(int s = 1) const;
 
    StrElt homothety(const UINT s) const;
 
    StrElt transpose() const;
 
    StrElt merge(const StrElt &rhs);
 
    StrElt noCenter() const;
 
    virtual seType getType() const
    {
      return seT;
    }
 
    void setName(string name)
    {
      this->name = name;
    }
 
    void setName()
    {
      std::map<seType, string> seNames = {
          {SE_Generic, "GenericSE"},
          {SE_Squ, "SquSE"},
          {SE_Squ0, "SquSE0"},
          {SE_Hex, "HexSE"},
          {SE_Hex0, "HexSE0"},
          {SE_Cross, "CrossSE"},
          {SE_Horiz, "HorizSE"},
          {SE_Vert, "VertSE"},
          {SE_Cube, "CubeSE"},
          {SE_Cross3D, "Cross3DSE"},
          {SE_Rhombicuboctahedron, "RhombicuboctahedronSE"},
          {SE_Line, "LineSE"},
          {SE_Line3D, "Line3DSE"},
          {SE_CenteredLine, "CenteredLineSE"},
          {SE_CenteredLine3D, "CenteredLine3DSE"}
      };
 
      std::map<seType, string>::iterator it;
      it = seNames.find(seT);
      if (it != seNames.end())
        this->name = seNames[seT];
      else
        this->name = "Unknown";
    }
 
    string getName()
    {
      return name;
    }
 
    virtual void printSelf(ostream &os = std::cout, string indent = "") const;
 
    virtual void printSelf(string indent) const
    {
      printSelf(std::cout, indent);
    }
 
    bool odd;
    seType seT;
    UINT size;
  };
 
  inline void operator<<(ostream &os, StrElt &se)
  {
    se.printSelf(os);
  }
 
  class SquSE : public StrElt
  {
  public:
    SquSE(UINT s = 1) : StrElt(false, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8)
    {
      className = "SquSE : StrElt";
      seT       = SE_Squ;
      size      = s;
      this->setName();
    }
  };
 
  class SquSE0 : public StrElt
  {
  public:
    typedef StrElt parentClass;
    SquSE0(UINT s = 1) : StrElt(false, 8, 1, 2, 3, 4, 5, 6, 7, 8)
    {
      className = "SquSE0";
      seT       = SE_Squ0;
      odd       = false;
      size      = s;
      this->setName();
    }
  };
 
  class HexSE : public StrElt
  {
  public:
    HexSE(UINT s = 1) : StrElt(true, 7, 0, 1, 2, 3, 4, 5, 6)
    {
      className = "HexSE : StrElt";
      seT       = SE_Hex;
      size      = s;
      this->setName();
    }
  };
 
  class HexSE0 : public StrElt
  {
  public:
    HexSE0(UINT s = 1) : StrElt(true, 6, 1, 2, 3, 4, 5, 6)
    {
      className = "HexSE0";
      seT       = SE_Hex0;
      size      = s;
      this->setName();
    }
  };
 
  class CrossSE : public StrElt
  {
  public:
    CrossSE(UINT s = 1) : StrElt(false, 5, 0, 1, 5, 3, 7)
    {
      className = "CrossSE : StrElt";
      seT       = SE_Cross;
      size      = s;
      this->setName();
    }
  };
 
  class HorizSE : public StrElt
  {
  public:
    HorizSE(UINT s = 1) : StrElt(false, 3, 0, 1, 5)
    {
      className = "HorizSE : StrElt";
      seT       = SE_Horiz;
      size      = s;
      this->setName();
    }
  };
 
  class VertSE : public StrElt
  {
  public:
    VertSE(UINT s = 1) : StrElt(false, 3, 0, 3, 7)
    {
      className = "VertSE : StrElt";
      seT       = SE_Vert;
      size      = s;
      this->setName();
    }
  };
 
  class CubeSE : public StrElt
  {
  public:
    CubeSE(UINT s = 1) : StrElt(s)
    {
      className = "CubeSE : StrElt";
      seT       = SE_Cube;
      odd       = false;
      this->setName();
 
      int zList[] = {0, -1, 1};
      for (int i = 0; i < 3; i++) {
        int z = zList[i];
        addPoint(0, 0, z);
        addPoint(1, 0, z);
        addPoint(1, -1, z);
        addPoint(0, -1, z);
        addPoint(-1, -1, z);
        addPoint(-1, 0, z);
        addPoint(-1, 1, z);
        addPoint(0, 1, z);
        addPoint(1, 1, z);
      }
    }
  };
 
  class Cross3DSE : public StrElt
  {
  public:
    Cross3DSE(UINT s = 1) : StrElt(s)
    {
      className = "Cross3DSE : StrElt";
      seT       = SE_Cross3D;
      odd       = false;
      this->setName();
 
      addPoint(0, 0, 0);
      addPoint(1, 0, 0);
      addPoint(0, -1, 0);
      addPoint(-1, 0, 0);
      addPoint(0, 1, 0);
      addPoint(0, 0, -1);
      addPoint(0, 0, 1);
    }
  };
 
  class RhombicuboctahedronSE : public StrElt
  {
  public:
    RhombicuboctahedronSE(UINT s = 1) : StrElt(s)
    {
      className = "RhombicuboctahedronSE : StrElt";
      seT       = SE_Rhombicuboctahedron;
      odd       = false;
      this->setName();
 
      int x, y, z;
 
      addPoint(0, 0, 0);
      for (x = -2; x <= 2; x++)
        for (y = -1; y <= 1; y++)
          for (z = -1; z <= 1; z++)
            addPoint(x, y, z);
      for (x = -1; x <= 1; x++)
        for (y = -2; y <= 2; y++)
          for (z = -1; z <= 1; z++)
            addPoint(x, y, z);
      for (x = -1; x <= 1; x++)
        for (y = -1; y <= 1; y++)
          for (z = -2; z <= 2; z++)
            addPoint(x, y, z);
    }
  };
 
  class LineSE : public StrElt
  {
  public :
    LineSE(int length, double theta) : StrElt(1)
    {
      className = "LineSE : StrElt";
      seT       = SE_Line;
      odd       = false;
      this->setName();
 
      int xf = round(length * cos(-theta * PI / 180.));
      int yf = round(length * sin(-theta * PI / 180.));
      //int xf = round(length * cos(-theta));
      // int yf = round(length * sin(-theta));
      vector<Point<int>> v;
 
      v = bresenhamPoints(0, 0, xf, yf);
      for (size_t i = 0; i < v.size(); i++)
        addPoint(v[i].x, v[i].y, v[i].z);
    }
  };
 
  class Line3DSE : public StrElt
  {
  public :
    Line3DSE(int length, double theta, double zeta) : StrElt(1)
    {
      className = "Line3DSE : StrElt";
      seT       = SE_Line3D;
      odd       = false;
      this->setName();
 
      double lenXY = abs(length * cos(zeta * PI / 180.));
 
      int zf = round(length * sin(zeta * PI / 180.));
      int xf = round(lenXY * cos(-theta * PI / 180.));
      int yf = round(lenXY * sin(-theta * PI / 180.));
 
      Bresenham line(0, 0, 0, xf, yf, zf);
      vector<IntPoint> v = line.getPoints();
      for (size_t i = 0; i < v.size(); i++)
        addPoint(v[i].x, v[i].y, v[i].z);
    }
  };
 
#if 1
  class CenteredLineSE : public StrElt
  {
  public :
    CenteredLineSE(int length, double theta = 0) : StrElt(1)
    {
      className = "CenteredLineSE : StrElt";
      seT       = SE_CenteredLine;
      odd       = false;
      this->setName();
 
      int xf = round(length * cos(-theta * PI / 180.) / 2);
      int yf = round(length * sin(-theta * PI / 180.) / 2);
      //int xf = round(length * cos(-theta));
      // int yf = round(length * sin(-theta));
 
      vector<Point<int>> v;
      v = bresenhamPoints(0, 0, xf, yf);
 
      for (size_t i = 0; i < v.size(); i++) {
        addPoint(v[i].x, v[i].y, v[i].z);
        if (v[i].x == 0 && v[i].y == 0 && v[i].z == 0)
          continue;
        addPoint(-v[i].x, -v[i].y, -v[i].z);
      }
    }
  };
#else
  inline StrElt CenteredLineSE(int length, double theta = 0)
  {
    StrElt se = LineSE(length / 2 + 1, theta);
    return se.merge(se.transpose());
  }
#endif
 
#if 1
  class CenteredLine3DSE : public StrElt
  {
  public :
    CenteredLine3DSE(int length, double theta = 0, double zeta = 0) : StrElt(1)
    {
      className = "CenteredLine3DSE : StrElt";
      seT       = SE_CenteredLine3D;
      odd       = false;
      this->setName();
 
      length /= 2;
      double lenXY = abs(length * cos(zeta * PI / 180.));
 
      int zf = round(length * sin(zeta * PI / 180.));
      int xf = round(lenXY * cos(-theta * PI / 180.));
      int yf = round(lenXY * sin(-theta * PI / 180.));
 
      Bresenham line(0, 0, 0, xf, yf, zf);
      vector<IntPoint> v = line.getPoints();
 
      for (size_t i = 0; i < v.size(); i++) {
        addPoint(v[i].x, v[i].y, v[i].z);
        if (v[i].x == 0 && v[i].y == 0 && v[i].z == 0)
          continue;
        addPoint(-v[i].x, -v[i].y, -v[i].z);
      }
    }
  };
#else
  inline StrElt CenteredLine3DSE(int length, double theta = 0, double zeta = 0)
  {
    StrElt se = Line3DSE(length / 2 + 1, theta, zeta);
    return se.merge(se.transpose());
  }
#endif
 
  // Shortcuts
  inline HexSE hSE(UINT s = 1)
  {
    return HexSE(s);
  }
  inline HexSE0 hSE0(UINT s = 1)
  {
    return HexSE0(s);
  }
  inline SquSE sSE(UINT s = 1)
  {
    return SquSE(s);
  }
  inline SquSE0 sSE0(UINT s = 1)
  {
    return SquSE0(s);
  }
  inline CrossSE cSE(UINT s = 1)
  {
    return CrossSE(s);
  }
  inline CubeSE cbSE(UINT s = 1)
  {
    return CubeSE(s);
  }
  inline RhombicuboctahedronSE rcoSE(UINT s = 1)
  {
    return RhombicuboctahedronSE(s);
  }
  inline StrElt buildLineSE(int length, int theta)
  {
    StrElt se;
 
    int xf = round(length * cos(theta * PI / 180.));
    int yf = round(length * sin(theta * PI / 180.));
 
    vector<Point<int>> v;
 
    v = bresenhamPoints(0, 0, xf, yf);
    for (size_t i = 0; i < v.size(); i++)
      se.addPoint(v[i].x, v[i].y, v[i].z);
    return se;
  }
 
 
  inline StrElt merge(StrElt se1, StrElt se2)
  {
    StrElt se;
 
    typename vector<IntPoint>::iterator it;
    for (it = se1.points.begin(); it != se1.points.end(); it++) {
      const IntPoint &p = *it;
      se.addPoint(p);
    }
    for (it = se2.points.begin(); it != se2.points.end(); it++) {
      const IntPoint &p = *it;
      se.addPoint(p);
    }
    return se;
  }
 
#define DEFAULT_SE Morpho::getDefaultSE()
 
} // namespace smil
 
#endif