Heed::polyline Class Reference

#include <polyline.h>

Inheritance diagram for Heed::polyline:

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

Protected Member Functions
virtual void	get_components (ActivePtr< absref_transmit > &aref_tran)
void	polyline_init (const point *fpt, int fqpt)
void	polyline_del (void)

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

Definition at line 26 of file polyline.h.

Constructor & Destructor Documentation

polyline() [1/5]

Heed::polyline::polyline ( void  )

inline

Definition at line 97 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 ( void  )

inline

Definition at line 110 of file polyline.h.

{ polyline_del(); }

Member Function Documentation

check_point_in()

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

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

Definition at line 97 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 (length(v1) < prec) {
        qpc++;
      } else {
        vec v2 = pc[qpc] - pt[n + 1];
        if (length(v2) < 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

Definition at line 129 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 150 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 = length(fpt - pt[n])) < mx) mx = sldist;
      if ((sldist = length(fpt - pt[n + 1])) < mx) mx = sldist;
    }
  }
  return mx;
}

Referenced by dist_two_inter().

distance() [2/2]

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

Definition at line 172 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 = length(fpt - pt[n])) < mx) {
        mx = sldist;
        fcpt = pt[n];
      }
      if ((sldist = length(fpt - pt[n + 1])) < mx) {
        mx = sldist;
        fcpt = pt[n + 1];
      }
    }
  }
  return mx;
}

get_components()

void Heed::polyline::get_components ( ActivePtr< absref_transmit > &  aref_tran )

protectedvirtual

Reimplemented from absref.

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

Definition at line 18 of file polyline.cpp.

                                                                   {
  aref_tran.pass(new absref_transmit(qpt + qsl, aref));
}

Gpt()

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

inline

Definition at line 35 of file polyline.h.

                         {  // there is no funname line, check directly
                            //check_econd12(n , >= , qpt , mcerr);
    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 ( void  ) const

inline

Definition at line 34 of file polyline.h.

{ return qpt; }

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

Gqsl()

int Heed::polyline::Gqsl ( void  ) const

inline

Definition at line 44 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 45 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 ( void  )

inlineprotected

Definition at line 81 of file polyline.h.

                          {
    if (pt != NULL) {
      delete[] pt;
      pt = NULL;
    }
    if (sl != NULL) {
      delete[] sl;
      sl = NULL;
    }
    if (aref != NULL) {
      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) {
    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];
  } else {
    qpt = 0;
    qsl = 0;
    pt = NULL;
    sl = NULL;
    aref = NULL;
  }
}

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 225 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 55 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 29 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 28 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 30 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 31 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