Heed::polygon Class Reference

Polygon in plane. More...

#include <polyline.h>

Inheritance diagram for Heed::polygon:

Public Member Functions
int	check_point_in (const point &fpt, vfloat prec) const
point	cross (const straight &fsl, vfloat prec) const
int	range (const point &fpt, const vec &dir, vfloat &rng, point &fptenr, vfloat prec) const
polygon &	operator= (const polygon &fpl)
	polygon ()
	polygon (const polygon &plg)
	polygon (const polyline_pl &fpl, int fs_convex)
	polygon (const straight *fsl, int fqsl, vfloat prec)
Public Member Functions inherited from Heed::polyline_pl
plane	Gpn () const
	polyline_pl ()
	polyline_pl (const polyline_pl &pl)
	polyline_pl (const plane &fpn, const point *fpt, int fqpt)
	polyline_pl (polyline &pl)
	polyline_pl (const polyline &pl)
polyline_pl &	operator= (const polyline_pl &fpl)
Public Member Functions inherited from Heed::polyline
int	Gqpt () const
point	Gpt (int n) const
int	Gqsl () const
straight	Gsl (int n) const
int	check_point_in (const point &fpt, vfloat prec) const
int	cross (const straight &fsl, point *pc, int &qpc, polyline *pl, int &qpl, vfloat prec) const
vfloat	dist_two_inter (polyline &pl, vfloat prec) const
	Distance between two intervals.
vfloat	distance (const point &fpt) const
vfloat	distance (const point &fpt, point &cpt) const
	Distance between two points.
	polyline ()
	polyline (polyline &pl)
	polyline (const polyline &pl)
	polyline (const point *fpt, int fqpt)
	polyline (const point &fpt1, const point &fpt2)
polyline &	operator= (const polyline &fpl)
	~polyline ()
Public Member Functions inherited from Heed::absref
virtual	~absref ()
	Destructor.
virtual void	down (const abssyscoor *fasc)
	Convert numbering representation of object to basical system of fasc.
virtual void	up (const abssyscoor *fasc)
	Convert numbering representation of objects to new system.
virtual void	turn (const vec &dir, vfloat angle)
	Turn around axis doing via center of coordinate system along dir.
virtual void	shift (const vec &dir)

Public Attributes
int	s_convex

Additional Inherited Members
Protected Member Functions inherited from Heed::polyline_pl
virtual absref_transmit	get_components () override
Protected Member Functions inherited from Heed::polyline
virtual absref_transmit	get_components () override
void	polyline_init (const point *fpt, int fqpt)
void	polyline_del ()
Protected Attributes inherited from Heed::polyline_pl
plane	pn
Protected Attributes inherited from Heed::polyline
int	qpt
point *	pt
int	qsl
straight *	sl
absref **	aref
Static Protected Attributes inherited from Heed::polyline_pl
static absref absref::*	aref_pl = (absref absref::*)&polyline_pl::pn

Detailed Description

Polygon in plane.

Definition at line 147 of file polyline.h.

Constructor & Destructor Documentation

polygon() [1/4]

Heed::polygon::polygon ( )

inline

Definition at line 161 of file polyline.h.

: polyline_pl(), s_convex(0) {}

Referenced by polygon(), Heed::rectangle::rectangle(), and Heed::spquadr::spquadr().

polygon() [2/4]

Heed::polygon::polygon ( const polygon &  plg )

inline

Definition at line 162 of file polyline.h.

                              : polyline_pl((polyline_pl)plg) {
    s_convex = plg.s_convex;
  }

polygon() [3/4]

Heed::polygon::polygon ( const polyline_pl &  fpl, int  fs_convex  )

inline

Definition at line 165 of file polyline.h.

      : polyline_pl(fpl), s_convex(fs_convex) {
    if (fpl.Gqpt() < 4 || fpl.Gpt(0) != fpl.Gpt(qpt - 1)) {  
      mcerr << "ERROR in polygon::polygon(polyline_pl& fpl, int fs_convex)\n";
      mcerr << "fpl.Gqpt() < 4 || fpl.Gpt(0)!=fpl.Gpt(qpt-1)\n";
      spexit(mcerr);
    }
  }

polygon() [4/4]

Heed::polygon::polygon	(	const straight *	fsl,
		int	fqsl,
		vfloat	prec
	)

Definition at line 280 of file polyline.cpp.

    : polyline_pl(), s_convex(1) {
  pvecerror("polygon::polygon(const straight* fsl, int fqsl)");
  check_econd11a(fqsl, < 3, "fqsl cannot be less 3\n", mcerr);
  int n, m;
  // now check that either the piv's of lines are not equal to each other,
  // or the dir's are not parallel.
  // It does not prove that input data are corrent, but more
  // explicit prove might take too much time.
  for (n = 0; n < fqsl - 1; n++)
    for (m = n + 1; m < fqsl; m++) {
      if (fsl[n].Gpiv() == fsl[m].Gpiv())
        if (check_par(fsl[n].Gdir(), fsl[m].Gdir(), 0) !=
            0)  // 1 par, -1 antipar
        {
          mcerr << "error in polyline_init(straight* fsl, int fqsl):\n"
                << "Parallel lines with the same pivot cannot form polygin\n";
          for (int k = 0; k < fqsl; k++)
            mcout << "n=" << k << " fsl[n]=" << fsl[k];
          spexit(mcerr);
        }
    }
  int qptl = fqsl + 1;
  point* ptl = new point[qptl];
  for (n = 1; n < fqsl; n++) {
    ptl[n] = fsl[n - 1].cross(fsl[n], prec);
    if (vecerror != 0) {
      mcerr << "error in polygon::polygon(straight* fsl, int fqsl):\n"
            << " straight lines are not crossed properly\n"
            << "fsl[n-1]=" << fsl[n - 1] << "fsl[n]=" << fsl[n]
            << "vecerror=" << vecerror << '\n';
      spexit(mcerr);
    }
  }
  ptl[0] = fsl[fqsl - 1].cross(fsl[0], prec);
  if (vecerror != 0) {
    mcerr << "error in polygon::polygon(straight* fsl, int fqsl):\n"
          << " straight lines are not crossed properly\n"
          << "fsl[fqsl-1]=" << fsl[fqsl - 1] << "fsl[0]=" << fsl[0]
          << "vecerror=" << vecerror << '\n';
    spexit(mcerr);
  }
  ptl[fqsl] = ptl[0];
  plane pnl = plane(fsl[0].Gpiv(), fsl[0].Gdir() || fsl[1].Gdir());
  polyline_pl pll(pnl, ptl, qptl);
  *this = polygon(pll, 1);
 
  delete[] ptl;
}

Member Function Documentation

check_point_in()

int Heed::polygon::check_point_in	(	const point &	fpt,
		vfloat	prec
	)		const

Definition at line 339 of file polyline.cpp.

                                                               {
  pvecerror("int polygon::check_point_in(point& fpt)");
  int i;
  if ((i = polyline::check_point_in(fpt, prec)) > 0) {
    return i;
  }
  if ((i = pn.check_point_in(fpt, prec)) == 0) {
    return i;
  }
  /* The idea of the following algorithm is circulating around the polygon
     and finding of two points, one gives the minimum angle relatively
     some(any) direction, another gives the maximal angle.
     The point resides inside polygon if they are the same at the end of
     circulation.
  */
  point endpt[2];
  endpt[0] = pt[0];  // which is really first or last, depends on pn.Gdir()
  endpt[1] = pt[0];
  double totang = 0;
  double ang, ang2;
  // int s_start[2];
  // s_start[0]=0;
  // s_start[1]=0;
  int n;
  for (n = 0; n < qpt - 1; n++) {
    ang2 = 0.0;
    ang = ang2projvec((pt[n] - fpt), (pt[n + 1] - fpt), pn.Gdir());
    if (ang <= M_PI) {
      // go to opposite direction of clock
      totang += ang;
    } else {
      ang2 = 2 * M_PI - ang;
      totang -= ang2;
    }
  }
 
  if (fabs(totang) > 6.0) return 3;
  return 0;
}

Referenced by cross().

cross()

point Heed::polygon::cross	(	const straight &	fsl,
		vfloat	prec
	)		const

Definition at line 379 of file polyline.cpp.

                                                           {
  pvecerror("point polygon::cross(straight& fsl)");
  point cpt = pn.cross(fsl);  // does it cross the plane
  // mcout<<"polygon::cross: cpt="<<cpt;
  // mcout<<"vecerror="<<vecerror<<'\n';
  if (vecerror != 0) return cpt;
  int s = check_point_in(cpt, prec);
  if (s > 0)
    return cpt;
  else {
    vecerror = 1;
    return cpt;
  }
}

operator=()

polygon & Heed::polygon::operator=

(

const polygon &

fpl

)

Definition at line 330 of file polyline.cpp.

                                              {
  mfunname("polygon& polygon::operator=(const polygon& fpl)");
  polyline_del();
  polyline_init(fpl.pt, fpl.qpt);
  pn = fpl.pn;
  s_convex = fpl.s_convex;
  return *this;
}

Referenced by Heed::spquadr::operator=(), and Heed::rectangle::rectangle().

range()

int Heed::polygon::range	(	const point &	fpt,
		const vec &	dir,
		vfloat &	rng,
		point &	fptenr,
		vfloat	prec
	)		const

Definition at line 393 of file polyline.cpp.

                                      {
  pvecerror(
      "int polygon::range(const point& fpt, const vec& dir, vfloat& rng, "
      " point &fptenr)");
  straight stl(fpt, dir);
  point pnt = cross(stl, prec);
  if (vecerror != 0) {
    vecerror = 0;
    return 0;
  }
  vec dif = pnt - fpt;
  const int i = check_par(dif, dir, prec);
  if (i == 1) {
    rng = dif.length();
    fptenr = pnt;
    return 1;
  } else
    return 0;
}

Member Data Documentation

s_convex

int Heed::polygon::s_convex

Definition at line 149 of file polyline.h.

Referenced by Heed::operator<<(), operator=(), and polygon().

---

The documentation for this class was generated from the following files:

• polyline.h
• polyline.cpp