Predicates1D.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#pragma once
 
#include <string>
 
#include "AdvancedFunctions1D.h"
 
#include "../system/TimeStamp.h"
 
#include "../view_map/Functions1D.h"
#include "../view_map/Interface1D.h"
 
#ifdef WITH_CXX_GUARDEDALLOC
#  include "MEM_guardedalloc.h"
#endif
 
namespace Freestyle {
 
//
// UnaryPredicate1D (base class for predicates in 1D)
//
 
class UnaryPredicate1D {
 public:
  bool result;
  void *py_up1D;
 
  UnaryPredicate1D()
  {
    py_up1D = NULL;
  }
 
  virtual ~UnaryPredicate1D()
  {
  }
 
  virtual string getName() const
  {
    return "UnaryPredicate1D";
  }
 
  virtual int operator()(Interface1D &inter);
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:UnaryPredicate1D")
#endif
};
 
//
// BinaryPredicate1D (base class for predicates in 1D)
//
 
class BinaryPredicate1D {
 public:
  bool result;
  void *py_bp1D;
 
  BinaryPredicate1D()
  {
    py_bp1D = NULL;
  }
 
  virtual ~BinaryPredicate1D()
  {
  }
 
  virtual string getName() const
  {
    return "BinaryPredicate1D";
  }
 
  virtual int operator()(Interface1D &inter1, Interface1D &inter2);
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:BinaryPredicate1D")
#endif
};
 
//
// Predicates definitions
//
 
namespace Predicates1D {
 
// TrueUP1D
class TrueUP1D : public UnaryPredicate1D {
 public:
  TrueUP1D()
  {
  }
 
  string getName() const
  {
    return "TrueUP1D";
  }
 
  int operator()(Interface1D &)
  {
    result = true;
    return 0;
  }
};
 
// FalseUP1D
class FalseUP1D : public UnaryPredicate1D {
 public:
  FalseUP1D()
  {
  }
 
  string getName() const
  {
    return "FalseUP1D";
  }
 
  int operator()(Interface1D &)
  {
    result = false;
    return 0;
  }
};
 
// QuantitativeInvisibilityUP1D
class QuantitativeInvisibilityUP1D : public UnaryPredicate1D {
 public:
  QuantitativeInvisibilityUP1D(unsigned qi = 0) : _qi(qi)
  {
  }
 
  string getName() const
  {
    return "QuantitativeInvisibilityUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    Functions1D::QuantitativeInvisibilityF1D func;
    if (func(inter) < 0) {
      return -1;
    }
    result = (func.result == _qi);
    return 0;
  }
 
 private:
  unsigned _qi;
};
 
// ContourUP1D
class ContourUP1D : public UnaryPredicate1D {
 private:
  Functions1D::CurveNatureF1D _getNature;
 
 public:
  string getName() const
  {
    return "ContourUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    if (_getNature(inter) < 0) {
      return -1;
    }
    if ((_getNature.result & Nature::SILHOUETTE) || (_getNature.result & Nature::BORDER)) {
      Interface0DIterator it = inter.verticesBegin();
      for (; !it.isEnd(); ++it) {
        if (Functions0D::getOccludeeF0D(it) != Functions0D::getShapeF0D(it)) {
          result = true;
          return 0;
        }
      }
    }
    result = false;
    return 0;
  }
};
 
// ExternalContourUP1D
class ExternalContourUP1D : public UnaryPredicate1D {
 private:
  Functions1D::CurveNatureF1D _getNature;
 
 public:
  string getName() const
  {
    return "ExternalContourUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    if (_getNature(inter) < 0) {
      return -1;
    }
    if ((_getNature.result & Nature::SILHOUETTE) || (_getNature.result & Nature::BORDER)) {
      set<ViewShape *> occluded;
      Functions1D::getOccludeeF1D(inter, occluded);
      for (set<ViewShape *>::iterator os = occluded.begin(), osend = occluded.end(); os != osend;
           ++os) {
        if ((*os) == 0) {
          result = true;
          return 0;
        }
      }
    }
    result = false;
    return 0;
  }
};
 
// EqualToTimeStampUP1D
class EqualToTimeStampUP1D : public UnaryPredicate1D {
 protected:
  unsigned _timeStamp;
 
 public:
  EqualToTimeStampUP1D(unsigned ts) : UnaryPredicate1D()
  {
    _timeStamp = ts;
  }
 
  string getName() const
  {
    return "EqualToTimeStampUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    result = (inter.getTimeStamp() == _timeStamp);
    return 0;
  }
};
 
// EqualToChainingTimeStampUP1D
class EqualToChainingTimeStampUP1D : public UnaryPredicate1D {
 protected:
  unsigned _timeStamp;
 
 public:
  EqualToChainingTimeStampUP1D(unsigned ts) : UnaryPredicate1D()
  {
    _timeStamp = ts;
  }
 
  string getName() const
  {
    return "EqualToChainingTimeStampUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    ViewEdge *edge = dynamic_cast<ViewEdge *>(&inter);
    if (!edge) {
      result = false;
      return 0;
    }
    result = (edge->getChainingTimeStamp() >= _timeStamp);
    return 0;
  }
};
 
// ShapeUP1D
class ShapeUP1D : public UnaryPredicate1D {
 private:
  Id _id;
 
 public:
  ShapeUP1D(unsigned idFirst, unsigned idSecond = 0) : UnaryPredicate1D()
  {
    _id = Id(idFirst, idSecond);
  }
 
  string getName() const
  {
    return "ShapeUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    set<ViewShape *> shapes;
    Functions1D::getShapeF1D(inter, shapes);
    for (set<ViewShape *>::iterator s = shapes.begin(), send = shapes.end(); s != send; ++s) {
      if ((*s)->getId() == _id) {
        result = true;
        return 0;
      }
    }
    result = false;
    return 0;
  }
};
 
// WithinImageBoundaryUP1D
class WithinImageBoundaryUP1D : public UnaryPredicate1D {
 private:
  real _xmin, _ymin, _xmax, _ymax;
 
 public:
  WithinImageBoundaryUP1D(const real xmin, const real ymin, const real xmax, const real ymax)
      : _xmin(xmin), _ymin(ymin), _xmax(xmax), _ymax(ymax)
  {
  }
 
  string getName() const
  {
    return "WithinImageBoundaryUP1D";
  }
 
  int operator()(Interface1D &inter)
  {
    // 1st pass: check if a point is within the image boundary.
    Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
    for (; it != itend; ++it) {
      real x = (*it).getProjectedX();
      real y = (*it).getProjectedY();
      if (_xmin <= x && x <= _xmax && _ymin <= y && y <= _ymax) {
        result = true;
        return 0;
      }
    }
    // 2nd pass: check if a line segment intersects with the image boundary.
    it = inter.verticesBegin();
    if (it != itend) {
      Vec2r pmin(_xmin, _ymin);
      Vec2r pmax(_xmax, _ymax);
      Vec2r prev((*it).getPoint2D());
      ++it;
      for (; it != itend; ++it) {
        Vec2r p((*it).getPoint2D());
        if (GeomUtils::intersect2dSeg2dArea(pmin, pmax, prev, p)) {
          result = true;
          return 0;
        }
        prev = p;
      }
    }
    result = false;
    return 0;
  }
};
 
//
//   Binary Predicates definitions
//
 
// TrueBP1D
class TrueBP1D : public BinaryPredicate1D {
 public:
  string getName() const
  {
    return "TrueBP1D";
  }
 
  int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/)
  {
    result = true;
    return 0;
  }
};
 
// FalseBP1D
class FalseBP1D : public BinaryPredicate1D {
 public:
  string getName() const
  {
    return "FalseBP1D";
  }
 
  int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/)
  {
    result = false;
    return 0;
  }
};
 
// Length2DBP1D
class Length2DBP1D : public BinaryPredicate1D {
 public:
  string getName() const
  {
    return "Length2DBP1D";
  }
 
  int operator()(Interface1D &i1, Interface1D &i2)
  {
    result = (i1.getLength2D() > i2.getLength2D());
    return 0;
  }
};
 
// SameShapeIdBP1D
class SameShapeIdBP1D : public BinaryPredicate1D {
 public:
  string getName() const
  {
    return "SameShapeIdBP1D";
  }
 
  int operator()(Interface1D &i1, Interface1D &i2)
  {
    set<ViewShape *> shapes1;
    Functions1D::getShapeF1D(i1, shapes1);
    set<ViewShape *> shapes2;
    Functions1D::getShapeF1D(i2, shapes2);
    // FIXME:// n2 algo, can do better...
    for (set<ViewShape *>::iterator s = shapes1.begin(), send = shapes1.end(); s != send; ++s) {
      Id current = (*s)->getId();
      for (set<ViewShape *>::iterator s2 = shapes2.begin(), s2end = shapes2.end(); s2 != s2end;
           ++s2) {
        if ((*s2)->getId() == current) {
          result = true;
          return 0;
        }
      }
    }
    result = false;
    return 0;
  }
};
 
// ViewMapGradientNormBP1D
class ViewMapGradientNormBP1D : public BinaryPredicate1D {
 private:
  Functions1D::GetViewMapGradientNormF1D _func;
 
 public:
  ViewMapGradientNormBP1D(int level, IntegrationType iType = MEAN, float sampling = 2.0)
      : BinaryPredicate1D(), _func(level, iType, sampling)
  {
  }
 
  string getName() const
  {
    return "ViewMapGradientNormBP1D";
  }
 
  int operator()(Interface1D &i1, Interface1D &i2)
  {
    if (_func(i1) < 0) {
      return -1;
    }
    real n1 = _func.result;
    if (_func(i2) < 0) {
      return -1;
    }
    real n2 = _func.result;
    result = (n1 > n2);
    return 0;
  }
};
 
}  // end of namespace Predicates1D
 
} /* namespace Freestyle */