Heed::polygon Class Reference

#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 (void)
	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 (void) const
	polyline_pl (void)
	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 (void) const
point	Gpt (int n) const
int	Gqsl (void) 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
vfloat	distance (const point &fpt) const
vfloat	distance (const point &fpt, point &cpt) const
	polyline (void)
	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 (void)
Public Member Functions inherited from absref
virtual	~absref ()
virtual void	down (const abssyscoor *fasc)
virtual void	up (const abssyscoor *fasc)
virtual void	turn (const vec &dir, vfloat angle)
virtual void	shift (const vec &dir)

Public Attributes
int	s_convex

Additional Inherited Members
Protected Member Functions inherited from Heed::polyline_pl
virtual void	get_components (ActivePtr< absref_transmit > &aref_tran)
Protected Member Functions inherited from Heed::polyline
virtual void	get_components (ActivePtr< absref_transmit > &aref_tran)
void	polyline_init (const point *fpt, int fqpt)
void	polyline_del (void)
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 absrefabsref::*	aref_pl = (absref absref::*)&polyline_pl::pn

Detailed Description

Definition at line 154 of file polyline.h.

Constructor & Destructor Documentation

polygon() [1/4]

Heed::polygon::polygon ( void  )

inline

Definition at line 169 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 170 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 173 of file polyline.h.

      : polyline_pl(fpl), s_convex(fs_convex) {
    if (fpl.Gqpt() < 4 ||
        fpl.Gpt(0) !=
            fpl.Gpt(qpt -
                    1)) {  // 4 repeats 1, so different points are 3 or more
      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 285 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 345 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 385 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 336 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::rectangle::rectangle().

range()

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

Definition at line 399 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 = length(dif);
    fptenr = pnt;
    return 1;
  } else
    return 0;
}

Member Data Documentation

s_convex

int Heed::polygon::s_convex

Definition at line 157 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