#include <blobs.h>

Public Member Functions
	TESSLINE ()

	TESSLINE (const TESSLINE &src)

	~TESSLINE ()

TESSLINE &	operator= (const TESSLINE &src)

void	CopyFrom (const TESSLINE &src)

void	Clear ()

void	Normalize (const DENORM &denorm)

void	Rotate (const FCOORD rotation)

void	Move (const ICOORD vec)

void	Scale (float factor)

void	SetupFromPos ()

void	ComputeBoundingBox ()

void	MinMaxCrossProduct (const TPOINT vec, int min_xp, int max_xp) const

TBOX	bounding_box () const

bool	SameBox (const TESSLINE &other) const

bool	SegmentCrosses (const TPOINT &pt1, const TPOINT &pt2) const

bool	Contains (const TPOINT &pt) const

void	plot (ScrollView *window, ScrollView::Color color, ScrollView::Color child_color)

EDGEPT *	FindBestStartPt () const

int	BBArea () const

Static Public Member Functions
static TESSLINE *	BuildFromOutlineList (EDGEPT *outline)

Public Attributes
TPOINT	topleft

TPOINT	botright

TPOINT	start

bool	is_hole

EDGEPT *	loop

TESSLINE *	next

Detailed Description

Definition at line 182 of file blobs.h.

Constructor & Destructor Documentation

TESSLINE::TESSLINE ( )

inline

Definition at line 183 of file blobs.h.

183 : is_hole(false), loop(nullptr), next(nullptr) {}

TESSLINE::next

TESSLINE * next

Definition: blobs.h:260

TESSLINE::loop

EDGEPT * loop

Definition: blobs.h:259

TESSLINE::is_hole

bool is_hole

Definition: blobs.h:258

TESSLINE::TESSLINE ( const TESSLINE & src )

inline

Definition at line 184 of file blobs.h.

                                 : loop(nullptr), next(nullptr) {
     CopyFrom(src);
   }

TESSLINE::~TESSLINE ( )

inline

Definition at line 187 of file blobs.h.

               {
     Clear();
   }

Member Function Documentation

int TESSLINE::BBArea ( ) const

inline

Definition at line 251 of file blobs.h.

                      {
     return (botright.x - topleft.x) * (topleft.y - botright.y);
   }

TBOX TESSLINE::bounding_box ( ) const

Definition at line 261 of file blobs.cpp.

                                   {
   return TBOX(topleft.x, botright.y, botright.x, topleft.y);
 }

TESSLINE * TESSLINE::BuildFromOutlineList ( EDGEPT * outline )

static

Definition at line 98 of file blobs.cpp.

                                                         {
   auto* result = new TESSLINE;
   result->loop = outline;
   if (outline->src_outline != nullptr) {
     // ASSUMPTION: This function is only ever called from ApproximateOutline
     // and therefore either all points have a src_outline or all do not.
     // Just as SetupFromPos sets the vectors from the vertices, setup the
     // step_count members to indicate the (positive) number of original
     // C_OUTLINE steps to the next vertex.
     EDGEPT* pt = outline;
     do {
       pt->step_count = pt->next->start_step - pt->start_step;
       if (pt->step_count < 0) pt->step_count += pt->src_outline->pathlength();
       pt = pt->next;
     } while (pt != outline);
   }
   result->SetupFromPos();
   return result;
 }

void TESSLINE::Clear ( )

Definition at line 146 of file blobs.cpp.

                      {
   if (loop == nullptr) return;
 
   EDGEPT* this_edge = loop;
   do {
     EDGEPT* next_edge = this_edge->next;
     delete this_edge;
     this_edge = next_edge;
   } while (this_edge != loop);
   loop = nullptr;
 }

void TESSLINE::ComputeBoundingBox ( )

Definition at line 217 of file blobs.cpp.

                                   {
   int minx = INT32_MAX;
   int miny = INT32_MAX;
   int maxx = -INT32_MAX;
   int maxy = -INT32_MAX;
 
   // Find boundaries.
   start = loop->pos;
   EDGEPT* this_edge = loop;
   do {
     if (!this_edge->IsHidden() || !this_edge->prev->IsHidden()) {
       if (this_edge->pos.x < minx) minx = this_edge->pos.x;
       if (this_edge->pos.y < miny) miny = this_edge->pos.y;
       if (this_edge->pos.x > maxx) maxx = this_edge->pos.x;
       if (this_edge->pos.y > maxy) maxy = this_edge->pos.y;
     }
     this_edge = this_edge->next;
   } while (this_edge != loop);
   // Reset bounds.
   topleft.x = minx;
   topleft.y = maxy;
   botright.x = maxx;
   botright.y = miny;
 }

bool TESSLINE::Contains ( const TPOINT & pt ) const

inline

Definition at line 236 of file blobs.h.

                                         {
     return topleft.x <= pt.x && pt.x <= botright.x &&
            botright.y <= pt.y && pt.y <= topleft.y;
   }

void TESSLINE::CopyFrom ( const TESSLINE & src )

Definition at line 119 of file blobs.cpp.

                                            {
   Clear();
   topleft = src.topleft;
   botright = src.botright;
   start = src.start;
   is_hole = src.is_hole;
   if (src.loop != nullptr) {
     EDGEPT* prevpt = nullptr;
     EDGEPT* newpt = nullptr;
     EDGEPT* srcpt = src.loop;
     do {
       newpt = new EDGEPT(*srcpt);
       if (prevpt == nullptr) {
         loop = newpt;
       } else {
         newpt->prev = prevpt;
         prevpt->next = newpt;
       }
       prevpt = newpt;
       srcpt = srcpt->next;
     } while (srcpt != src.loop);
     loop->prev = newpt;
     newpt->next = loop;
   }
 }

EDGEPT * TESSLINE::FindBestStartPt ( ) const

Definition at line 287 of file blobs.cpp.

                                         {
   EDGEPT* best_start = loop;
   int best_step = loop->start_step;
   // Iterate the polygon.
   EDGEPT* pt = loop;
   do {
     if (pt->IsHidden()) continue;
     if (pt->prev->IsHidden() || pt->prev->src_outline != pt->src_outline)
       return pt;  // Qualifies as the best.
     if (pt->start_step < best_step) {
       best_step = pt->start_step;
       best_start = pt;
     }
   } while ((pt = pt->next) != loop);
   return best_start;
 }

void TESSLINE::MinMaxCrossProduct	(	const TPOINT	vec,
		int *	min_xp,
		int *	max_xp
	)		const

Definition at line 247 of file blobs.cpp.

                                                      {
   *min_xp = INT32_MAX;
   *max_xp = INT32_MIN;
   EDGEPT* this_edge = loop;
   do {
     if (!this_edge->IsHidden() || !this_edge->prev->IsHidden()) {
       int product = CROSS(this_edge->pos, vec);
       UpdateRange(product, min_xp, max_xp);
     }
     this_edge = this_edge->next;
   } while (this_edge != loop);
 }

void TESSLINE::Move ( const ICOORD vec )

Definition at line 183 of file blobs.cpp.

                                     {
   EDGEPT* pt = loop;
   do {
     pt->pos.x += vec.x();
     pt->pos.y += vec.y();
     pt = pt->next;
   } while (pt != loop);
   SetupFromPos();
 }

void TESSLINE::Normalize ( const DENORM & denorm )

Definition at line 159 of file blobs.cpp.

                                              {
   EDGEPT* pt = loop;
   do {
     denorm.LocalNormTransform(pt->pos, &pt->pos);
     pt = pt->next;
   } while (pt != loop);
   SetupFromPos();
 }

TESSLINE& TESSLINE::operator= ( const TESSLINE & src )

inline

Definition at line 190 of file blobs.h.

                                            {
     CopyFrom(src);
     return *this;
   }

void TESSLINE::plot	(	ScrollView *	window,
		ScrollView::Color	color,
		ScrollView::Color	child_color
	)

Definition at line 266 of file blobs.cpp.

                                                  {
   if (is_hole)
     window->Pen(child_color);
   else
     window->Pen(color);
   window->SetCursor(start.x, start.y);
   EDGEPT* pt = loop;
   do {
     bool prev_hidden = pt->IsHidden();
     pt = pt->next;
     if (prev_hidden)
       window->SetCursor(pt->pos.x, pt->pos.y);
     else
       window->DrawTo(pt->pos.x, pt->pos.y);
   } while (pt != loop);
 }

void TESSLINE::Rotate ( const FCOORD rotation )

Definition at line 169 of file blobs.cpp.

                                       {
   EDGEPT* pt = loop;
   do {
     int tmp = static_cast<int>(
         floor(pt->pos.x * rot.x() - pt->pos.y * rot.y() + 0.5));
     pt->pos.y = static_cast<int>(
         floor(pt->pos.y * rot.x() + pt->pos.x * rot.y() + 0.5));
     pt->pos.x = tmp;
     pt = pt->next;
   } while (pt != loop);
   SetupFromPos();
 }

bool TESSLINE::SameBox ( const TESSLINE & other ) const

inline

Definition at line 221 of file blobs.h.

                                             {
     return topleft == other.topleft && botright == other.botright;
   }

void TESSLINE::Scale ( float factor )

Definition at line 194 of file blobs.cpp.

                                  {
   EDGEPT* pt = loop;
   do {
     pt->pos.x = static_cast<int>(floor(pt->pos.x * factor + 0.5));
     pt->pos.y = static_cast<int>(floor(pt->pos.y * factor + 0.5));
     pt = pt->next;
   } while (pt != loop);
   SetupFromPos();
 }

bool TESSLINE::SegmentCrosses	(	const TPOINT &	pt1,
		const TPOINT &	pt2
	)		const

inline

Definition at line 225 of file blobs.h.

                                                                   {
     if (Contains(pt1) && Contains(pt2)) {
       EDGEPT* pt = loop;
       do {
         if (TPOINT::IsCrossed(pt1, pt2, pt->pos, pt->next->pos)) return true;
         pt = pt->next;
       } while (pt != loop);
     }
     return false;
   }

void TESSLINE::SetupFromPos ( )

Definition at line 205 of file blobs.cpp.

                             {
   EDGEPT* pt = loop;
   do {
     pt->vec.x = pt->next->pos.x - pt->pos.x;
     pt->vec.y = pt->next->pos.y - pt->pos.y;
     pt = pt->next;
   } while (pt != loop);
   start = pt->pos;
   ComputeBoundingBox();
 }

Member Data Documentation

TPOINT TESSLINE::botright

Definition at line 256 of file blobs.h.

bool TESSLINE::is_hole

Definition at line 258 of file blobs.h.

EDGEPT* TESSLINE::loop

Definition at line 259 of file blobs.h.

TESSLINE* TESSLINE::next

Definition at line 260 of file blobs.h.

TPOINT TESSLINE::start

Definition at line 257 of file blobs.h.

TPOINT TESSLINE::topleft

Definition at line 255 of file blobs.h.

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

src/ccstruct/blobs.h
src/ccstruct/blobs.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation