Heed::polyline Class Reference

Polyline. More...

#include <polyline.h>

Inheritance diagram for Heed::polyline:

Public Member Functions
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)

Protected Member Functions
virtual absref_transmit	get_components () override
void	polyline_init (const point *fpt, int fqpt)
void	polyline_del ()

Protected Attributes
int	qpt
point *	pt
int	qsl
straight *	sl
absref **	aref

Friends
int	plane::cross (const polyline &pll, point *crpt, int &qcrpt, polyline *crpll, int &qcrpll, vfloat prec) const
std::ostream &	operator<< (std::ostream &file, const polyline &p)

Detailed Description

Polyline.

Definition at line 23 of file polyline.h.

Constructor & Destructor Documentation

polyline() [1/5]

Heed::polyline::polyline ( )

inline

Definition at line 92 of file polyline.h.

             {
    point ptl;
    polyline_init(&ptl, 0);
  }

Referenced by cross().

polyline() [2/5]

Heed::polyline::polyline

(

polyline &

pl

)

Definition at line 22 of file polyline.cpp.

                               : absref(pl) {
  mfunname("polyline::polyline(      polyline &pl)");
  polyline_init(pl.pt, pl.qpt);
}

polyline() [3/5]

Heed::polyline::polyline

(

const polyline &

pl

)

Definition at line 26 of file polyline.cpp.

                                     : absref(pl) {
  mfunname("polyline::polyline(const polyline &pl)");
  polyline_init(pl.pt, pl.qpt);
}

polyline() [4/5]

Heed::polyline::polyline	(	const point *	fpt,
		int	fqpt
	)

Definition at line 30 of file polyline.cpp.

                                             {
  mfunname("polyline::polyline(const point* fpt, int fqpt)");
  polyline_init(fpt, fqpt);
}

polyline() [5/5]

Heed::polyline::polyline	(	const point &	fpt1,
		const point &	fpt2
	)

Definition at line 34 of file polyline.cpp.

                                                       {
  // interval
  mfunname("polyline::polyline(const point& fpt1, const point& fpt2)");
  point fpt[2];
  fpt[0] = fpt1;
  fpt[1] = fpt2;
  polyline_init(fpt, 2);
}

~polyline()

Heed::polyline::~polyline ( )

inline

Definition at line 105 of file polyline.h.

{ polyline_del(); }

Member Function Documentation

check_point_in()

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

Return whether a point is inside. 0 point is not in 1 point coincides with an edge 2 point is inside an interval

Definition at line 76 of file polyline.cpp.

                                                                {
  pvecerror("int polyline::check_point_in(point& fpt, vfloat prec)");
  for (int n = 0; n < qpt; ++n) {
    if (apeq(pt[n], fpt, prec)) return 1;
  }
  for (int n = 0; n < qsl; ++n) {
    if (sl[n].check_point_in(fpt, prec) == 1) {
      vec v1 = fpt - pt[n];
      vec v2 = fpt - pt[n + 1];
      if (check_par(v1, v2, prec) == -1) {
        // anti-parallel vectors, point inside borders
        return 2;
      }
    }
  }
  return 0;
}

Referenced by check_point_in(), Heed::polygon::check_point_in(), and dist_two_inter().

cross()

int Heed::polyline::cross	(	const straight &	fsl,
		point *	pc,
		int &	qpc,
		polyline *	pl,
		int &	qpl,
		vfloat	prec
	)		const

If straight line goes exactly by segment of polyline, the fuction gives two end points of adjacent segments and the segment itself. If one of the points is common, it is given several times. For example, if line crosses break point the point is given two times.

Definition at line 94 of file polyline.cpp.

                                                 {
  pvecerror("void polyline::cross(const straight& fsl, ...)");
  qpc = 0;
  qpl = 0;
  for (int n = 0; n < qsl; ++n) {
    pc[qpc] = sl[n].cross(fsl, prec);
    if (vecerror == 1 || vecerror == 2) {
      // lines do not cross
      vecerror = 0;
    } else if (vecerror == 3) {
      // the same straight line
      pl[qpl++] = polyline(&(pt[n]), 2);
    } else {
      vec v1 = pc[qpc] - pt[n];
      if (v1.length() < prec) {
        qpc++;
      } else {
        vec v2 = pc[qpc] - pt[n + 1];
        if (v2.length() < prec) {
          qpc++;
        } else if (check_par(v1, v2, prec) == -1) {
          // anti-parallel vectors, point inside borders
          qpc++;
        }
      }
    }
  }
  if (qpc > 0 || qpl > 0) return 1;
  return 0;
}

dist_two_inter()

vfloat Heed::polyline::dist_two_inter	(	polyline &	pl,
		vfloat	prec
	)		const

Distance between two intervals.

Definition at line 126 of file polyline.cpp.

                                                                {
  pvecerror("vfloat polyline::dist_two_inter(polyline& pl)");
  const polyline& pl1 = *this;
  check_econd11(pl1.Gqpt(), != 2, mcerr);
  check_econd11(pl2.Gqpt(), != 2, mcerr);
  point cpt[2];
  int type_of_cross;
  vfloat sldist = pl1.Gsl(0).distance(pl2.Gsl(0), type_of_cross, cpt);
  if (type_of_cross == 2 || type_of_cross == 3) return sldist;
  if (pl1.check_point_in(cpt[0], prec) > 0 &&
      pl2.check_point_in(cpt[1], prec) > 0)
    return sldist;
  vfloat mx = max_vfloat;
  vfloat r;
  if ((r = pl1.distance(pl2.Gpt(0))) < mx) mx = r;
  if ((r = pl1.distance(pl2.Gpt(1))) < mx) mx = r;
  if ((r = pl2.distance(pl1.Gpt(0))) < mx) mx = r;
  if ((r = pl2.distance(pl1.Gpt(1))) < mx) mx = r;
  return mx;
}

distance() [1/2]

vfloat Heed::polyline::distance

(

const point &

fpt

)

const

Definition at line 147 of file polyline.cpp.

                                                {
  pvecerror("vfloat polyline::distance(const point& fpt) const");
  check_econd11(qsl, <= 0, mcerr);
  vfloat sldist;
  point cpt;
  vfloat mx = max_vfloat;
  int n;
  for (n = 0; n < qsl; n++) {
    sldist = sl[n].distance(fpt, cpt);
    vec v1 = cpt - pt[n];
    vec v2 = cpt - pt[n + 1];
    if (check_par(v1, v2, 0.01) ==
        -1) {  // anti-parallel vectors, point inside borders
      if (sldist < mx) mx = sldist;
    } else {
      if ((sldist = (fpt - pt[n]).length()) < mx) mx = sldist;
      if ((sldist = (fpt - pt[n + 1]).length()) < mx) mx = sldist;
    }
  }
  return mx;
}

Referenced by dist_two_inter().

distance() [2/2]

vfloat Heed::polyline::distance	(	const point &	fpt,
		point &	cpt
	)		const

Distance between two points.

Definition at line 169 of file polyline.cpp.

                                                             {
  pvecerror("vfloat polyline::distance(const point& fpt) const");
  check_econd11(qsl, <= 0, mcerr);
  vfloat sldist;
  point cpt;
  vfloat mx = max_vfloat;
  int n;
  for (n = 0; n < qsl; n++) {
    sldist = sl[n].distance(fpt, cpt);
    vec v1 = cpt - pt[n];
    vec v2 = cpt - pt[n + 1];
    if (check_par(v1, v2, 0.01) ==
        -1) {  // anti-parallel vectors, point inside borders
      if (sldist < mx) {
        mx = sldist;
        fcpt = cpt;
      }
    } else {
      if ((sldist = (fpt - pt[n]).length()) < mx) {
        mx = sldist;
        fcpt = pt[n];
      }
      if ((sldist = (fpt - pt[n + 1]).length()) < mx) {
        mx = sldist;
        fcpt = pt[n + 1];
      }
    }
  }
  return mx;
}

get_components()

absref_transmit Heed::polyline::get_components ( )

overrideprotectedvirtual

Reimplemented from Heed::absref.

Reimplemented in Heed::polyline_pl, Heed::rectangle, and Heed::spquadr.

Definition at line 18 of file polyline.cpp.

                                         {
  return absref_transmit(qpt + qsl, aref);
}

Gpt()

point Heed::polyline::Gpt ( int  n ) const

inline

Definition at line 32 of file polyline.h.

                         {  
    if (n >= qpt) {
      mcerr << "error in polyline:Gpt(int n): n>qpt: n=" << n << " qpt=" << qpt
            << '\n';
      spexit(mcerr);
    }
    return pt[n];
  }

Referenced by Heed::cross4pllines(), dist_two_inter(), and Heed::polygon::polygon().

Gqpt()

int Heed::polyline::Gqpt ( ) const

inline

Definition at line 31 of file polyline.h.

{ return qpt; }

Referenced by dist_two_inter(), and Heed::polygon::polygon().

Gqsl()

int Heed::polyline::Gqsl ( ) const

inline

Definition at line 40 of file polyline.h.

{ return qsl; }

Referenced by Heed::splane::cross(), and Heed::polyline_pl::polyline_pl().

Gsl()

straight Heed::polyline::Gsl ( int  n ) const

inline

Definition at line 41 of file polyline.h.

                            {
    if (n >= qsl) {
      mcerr << "error in polyline:Gpt(int n): n>qsl: n=" << n << " qsl=" << qsl
            << '\n';
      spexit(mcerr);
    }
    return sl[n];
  }

Referenced by dist_two_inter(), and Heed::polyline_pl::polyline_pl().

operator=()

polyline & Heed::polyline::operator=

(

const polyline &

fpl

)

Definition at line 43 of file polyline.cpp.

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

Referenced by Heed::polyline_pl::polyline_pl().

polyline_del()

void Heed::polyline::polyline_del ( )

inlineprotected

Definition at line 76 of file polyline.h.

                      {
    if (pt) {
      delete[] pt;
      pt = NULL;
    }
    if (sl) {
      delete[] sl;
      sl = NULL;
    }
    if (aref) {
      delete[] aref;
      aref = NULL;
    }
  }

Referenced by Heed::polygon::operator=(), operator=(), Heed::polyline_pl::operator=(), and ~polyline().

polyline_init()

void Heed::polyline::polyline_init ( const point *  fpt, int  fqpt  )

protected

Definition at line 50 of file polyline.cpp.

                                                       {
  pvecerror("void polyline::polyline_init(const point* fpt, int fqpt)");
  check_econd11(fqpt, < 0, mcerr)
  if (fqpt < 1) {
    qpt = 0;
    qsl = 0;
    pt = NULL;
    sl = NULL;
    aref = NULL;
    return;
  } 
  pt = new point[fqpt];
  for (qpt = 0; qpt < fqpt; ++qpt) pt[qpt] = fpt[qpt];
  if (fqpt >= 2) {
    sl = new straight[qpt - 1];
    for (qsl = 0; qsl < qpt - 1; ++qsl) {
      sl[qsl] = straight(pt[qsl], pt[qsl + 1]);
    }
  } else {
    sl = NULL;
  }
  aref = new absref* [qpt + qsl];
  for (int n = 0; n < qpt; ++n) aref[n] = &pt[n];
  for (int n = 0; n < qsl; ++n) aref[n + qpt] = &sl[n];
}

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

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  file, const polyline &  p  )

friend

Definition at line 221 of file polyline.cpp.

                                                            {
  int n;
  Ifile << "polyline:\n";
  indn.n += 2;
  Ifile << "qpt=" << p.qpt << '\n';
  for (n = 0; n < p.qpt; n++) file << p.pt[n];
  Ifile << "qsl=" << p.qsl << '\n';
  for (n = 0; n < p.qsl; n++) file << p.sl[n];
  indn.n -= 2;
  return file;
}

plane::cross

int plane::cross ( const polyline &  pll, point *  crpt, int &  qcrpt, polyline *  crpll, int &  qcrpll, vfloat  prec  ) const

friend

Referenced by Heed::spquadr::apos(), Heed::spquadr::perpos(), and Heed::polygon::range().

Member Data Documentation

aref

absref** Heed::polyline::aref

protected

Definition at line 51 of file polyline.h.

Referenced by get_components(), Heed::polyline_pl::get_components(), Heed::rectangle::get_components(), Heed::spquadr::get_components(), polyline_del(), and polyline_init().

pt

point* Heed::polyline::pt

protected

Definition at line 26 of file polyline.h.

Referenced by check_point_in(), Heed::polygon::check_point_in(), Heed::plane::cross(), cross(), distance(), Gpt(), Heed::polygon::operator=(), operator=(), Heed::polyline_pl::operator=(), polyline(), polyline_del(), and polyline_init().

qpt

int Heed::polyline::qpt

protected

Definition at line 25 of file polyline.h.

Referenced by check_point_in(), Heed::polygon::check_point_in(), get_components(), Heed::polyline_pl::get_components(), Heed::rectangle::get_components(), Heed::spquadr::get_components(), Gpt(), Gqpt(), Heed::polygon::operator=(), operator=(), Heed::polyline_pl::operator=(), Heed::polygon::polygon(), polyline(), and polyline_init().

qsl

int Heed::polyline::qsl

protected

Definition at line 27 of file polyline.h.

Referenced by check_point_in(), Heed::plane::cross(), cross(), distance(), get_components(), Heed::polyline_pl::get_components(), Heed::rectangle::get_components(), Heed::spquadr::get_components(), Gqsl(), Gsl(), and polyline_init().

sl

straight* Heed::polyline::sl

protected

Definition at line 28 of file polyline.h.

Referenced by check_point_in(), Heed::plane::cross(), cross(), distance(), Gsl(), Heed::spquadr::perpos(), polyline_del(), and polyline_init().

---

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

• polyline.h
• polyline.cpp