Heed::plane Class Reference

Plane, defined by defined by a point and a vector normal to the plane. More...

#include <plane.h>

Inheritance diagram for Heed::plane:

Public Member Functions
point	Gpiv (void) const
vec	Gdir (void) const
	plane ()
	plane (const point &fpiv, const vec &fdir)
	plane (const straight &sl, const point &pt)
	plane (const straight &sl1, const straight &sl2, vfloat prec)
plane &	operator= (const plane &fpl)
int	check_point_in (const point &fp, vfloat prec) const
point	cross (const straight &sl) const
straight	cross (const plane &sl) const
int	cross (const polyline &pll, point *crpt, int &qcrpt, polyline *crpll, int &qcrpll, vfloat prec) const
vfloat	distance (const point &fpt) const
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 void	get_components (ActivePtr< absref_transmit > &aref_tran)

Protected Attributes
point	piv
	Origin point, pivot.
vec	dir
	Direction of normal, unit vector.

Static Protected Attributes
static absrefabsref::*[2]	aref

Friends
int	operator== (const plane &pl1, const plane &pl2)
int	operator!= (const plane &pl1, const plane &pl2)
bool	apeq (const plane &pl1, const plane &pl2, vfloat prec)
std::ostream &	operator<< (std::ostream &file, const plane &s)

Detailed Description

Plane, defined by defined by a point and a vector normal to the plane.

Definition at line 24 of file plane.h.

Constructor & Destructor Documentation

plane() [1/4]

Heed::plane::plane ( )

inline

Definition at line 40 of file plane.h.

: piv(), dir() { ; }

plane() [2/4]

Heed::plane::plane ( const point &  fpiv, const vec &  fdir  )

inline

Definition at line 41 of file plane.h.

                                            : piv(fpiv), dir(unit_vec(fdir)) {
    ;
  }

plane() [3/4]

Heed::plane::plane	(	const straight &	sl,
		const point &	pt
	)

Definition at line 25 of file plane.cpp.

                                                : piv(sl.Gpiv()), dir() {
  pvecerror("plane::plane( const straight& sl, const point& pt)");
  int i = sl.check_point_in(pt, 0.0);
  if (i != 0)
    vecerror = 1;
  else
    dir = unit_vec(sl.Gdir() || (pt - sl.Gpiv()));
}

plane() [4/4]

Heed::plane::plane	(	const straight &	sl1,
		const straight &	sl2,
		vfloat	prec
	)

Definition at line 33 of file plane.cpp.

    : piv(sl1.Gpiv()), dir() {
  pvecerror(
      "plane::plane( const straight& sl1, const straight& sl2, vfloat prec)");
  point pt = sl1.cross(sl2, prec);
  if (vecerror == 0) {
    piv = pt;
    dir = unit_vec(sl1.Gdir() || sl2.Gdir());
  } else if (vecerror == 2)  // different parallel lines
  {
    vecerror = 0;
    dir = unit_vec(sl1.Gdir() || (sl2.Gpiv() - sl1.Gpiv()));
  }
  // otherwise vecerror != 0
}

Member Function Documentation

check_point_in()

int Heed::plane::check_point_in	(	const point &	fp,
		vfloat	prec
	)		const

Definition at line 67 of file plane.cpp.

                                                            {
  pvecerror("int plane::check_point_in(point fp, vfloat prec)");
  vfloat f = distance(fp);
  if (f < prec) return 1;
  return 0;
}

Referenced by Heed::polygon::check_point_in(), Heed::splane::check_point_inside(), and Heed::splane::check_point_inside1().

cross() [1/3]

straight Heed::plane::cross

(

const plane &

sl

)

const

Definition at line 93 of file plane.cpp.

                                           {
  pvecerror("point plane::cross(plane &pl)");
  point plpiv = pl.Gpiv();
  vec pldir = pl.Gdir();
  vec a = dir || pldir;  // direction of the overall straight lines
  if (a.length() == 0) {
    if (plpiv == piv || check_par(pldir, dir, 0.0) != 0) {  // planes coinsides
      vecerror = 3;
      return straight();
    } else {
      vecerror = 2;
      return straight();
    }
  }
  a = unit_vec(a);
  vec c = a || dir;  // perpend. for ov. str.
  straight st(piv, c);
  point pt = pl.cross(st);  // one point on ov. str.
  return straight(pt, a);  // overall straight
}

cross() [2/3]

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

Definition at line 114 of file plane.cpp.

                                                 {
  pvecerror("int plane::cross(polyline &pll, ...");
 
  qcrpt = 0;
  qcrpll = 0;
  for (int n = 0; n < pll.qsl; n++) {
    point cpt = cross(pll.sl[n]);
    if (vecerror == 3)  // the line is in the plane
      crpll[qcrpll++] = polyline(&(pll.pt[n]), 2);
    else if (vecerror != 0)
      vecerror = 0;
    else {
      vec v1 = cpt - pll.pt[n];
      if (v1.length() < prec) {
        if (n == 0)  // otherwise it is probably included on the previous step
        {
          crpt[qcrpt++] = cpt;
        }
      } else {
        vec v2 = cpt - pll.pt[n + 1];
        if (v2.length() < prec)
          crpt[qcrpt++] = cpt;
        else if (check_par(v1, v2, prec) == -1)
          // anti-parallel vectors, point inside borders
          crpt[qcrpt++] = cpt;
      }
    }
  }
  if (qcrpt > 0 || qcrpll > 0)
    return 1;
  else
    return 0;
}

cross() [3/3]

point Heed::plane::cross

(

const straight &

sl

)

const

Definition at line 74 of file plane.cpp.

                                           {
  pvecerror("point plane::cross(straight &sl)");
  point slpiv = sl.Gpiv();
  vec sldir = sl.Gdir();
  vfloat r = dir * sldir;
  if (r == 0.0) {
    if (slpiv == piv || check_perp((piv - slpiv), dir, 0.0) == 1) {
      // Line is in plane
      vecerror = 3;
    } else {
      vecerror = 2;
    }
    return point();
  }
 
  vfloat t = (piv.v - slpiv.v) * dir;
  return point(slpiv.v + t / r * sldir);
}

Referenced by cross(), Heed::splane::cross(), Heed::polygon::cross(), Heed::splane::range(), Heed::straight::straight(), and Heed::straight::vecdistance().

distance()

vfloat Heed::plane::distance

(

const point &

fpt

)

const

Definition at line 149 of file plane.cpp.

                                             {
  pvecerror("vfloat plane::distance(point& fpt)");
  if (fpt == piv) return 0.0;
  vec v = fpt - piv;
  return fabs(v * dir);  // relys that dir is unit length vector
}

Referenced by check_point_in(), and Heed::circumf::cross().

Gdir()

vec Heed::plane::Gdir ( void  ) const

inline

Definition at line 33 of file plane.h.

{ return dir; }

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

get_components()

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

protectedvirtual

Reimplemented from Heed::absref.

Definition at line 21 of file plane.cpp.

                                                                {
  aref_tran.pass(new absref_transmit(2, aref));
}

Gpiv()

point Heed::plane::Gpiv ( void  ) const

inline

Definition at line 32 of file plane.h.

{ return piv; }

Referenced by Heed::splane::check_point_inside(), Heed::splane::check_point_inside1(), and cross().

operator=()

plane & Heed::plane::operator= ( const plane &  fpl )

inline

Definition at line 50 of file plane.h.

                                     {
    piv = fpl.piv;
    dir = fpl.dir;
    return *this;
  }

Friends And Related Function Documentation

apeq

bool apeq ( const plane &  pl1, const plane &  pl2, vfloat  prec  )

friend

Definition at line 60 of file plane.cpp.

                                                           {
  pvecerror("bool apeq(const plane &pl1, const plane &pl2, vfloat prec)");
  if (check_par(pl1.dir, pl2.dir, prec) == 0) return false;
  if (apeq(pl1.piv, pl2.piv, prec)) return true;
  return (pl1.check_point_in(pl2.piv, prec) == 1);
}

operator!=

int operator!= ( const plane &  pl1, const plane &  pl2  )

friend

Definition at line 57 of file plane.h.

                                                            {
    return pl1 == pl2 ? 0 : 1;
  }

operator<<

std::ostream & operator<< ( std::ostream &  file, const plane &  s  )

friend

Definition at line 156 of file plane.cpp.

                                                          {
  Ifile << "plane:\n";
  indn.n += 2;
  file << pl.piv << pl.dir;
  indn.n -= 2;
  return file;
}

operator==

int operator== ( const plane &  pl1, const plane &  pl2  )

friend

Definition at line 49 of file plane.cpp.

                                                   {
  pvecerror("int operator==(const plane &pl1, const plane &pl2)");
 
  if (!(pl1.dir == pl2.dir || pl1.dir == -pl2.dir)) return 0;
  if (pl1.piv == pl2.piv) return 1;
  if (pl1.check_point_in(pl2.piv, 0) == 1)
    return 1;
  else
    return 0;
}

Member Data Documentation

aref

absref absref::* Heed::plane::aref

staticprotected

Initial value:

= {(absref absref::*)&plane::piv,
                                    (absref absref::*)&plane::dir}

Definition at line 37 of file plane.h.

Referenced by get_components().

dir

vec Heed::plane::dir

protected

Direction of normal, unit vector.

Definition at line 29 of file plane.h.

Referenced by cross(), distance(), Gdir(), operator=(), and plane().

piv

point Heed::plane::piv

protected

Origin point, pivot.

Definition at line 27 of file plane.h.

Referenced by cross(), distance(), Gpiv(), operator=(), and plane().

---

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

• plane.h
• plane.cpp