tools::clist_contour Class Reference

Inheritance diagram for tools::clist_contour:

Collaboration diagram for tools::clist_contour:

Public Member Functions
virtual void	ExportLine (int iPlane, int x1, int y1, int x2, int y2)
	clist_contour ()
virtual	~clist_contour ()
cline_strip_list *	get_lines (unsigned int iPlane)
bool	compact_strips ()
virtual void	generate ()
Public Member Functions inherited from tools::ccontour
	ccontour ()
virtual	~ccontour ()
void	set_first_grid (int iCol, int iRow)
void	set_secondary_grid (int iCol, int iRow)
void	set_limits (double pLimits[4])
void	set_planes (const std::vector< double > &vPlanes)
void	set_field_fcn (double(*_pFieldFcn)(double, double, void *), void *)
size_t	get_number_of_planes () const
const std::vector< double > &	get_planes () const
double	get_plane (unsigned int i) const
double	get_xi (int i) const
double	get_yi (int i) const
void	get_limits (double pLimits[4])

Protected Member Functions
	clist_contour (const clist_contour &a_from)
virtual void	InitMemory ()
virtual void	CleanMemory ()
void	DumpPlane (unsigned int iPlane) const
	debuggin More...
double	Area (cline_strip *Line)
double	EdgeWeight (cline_strip *pLine, double R)
bool	MergeStrips (cline_strip *pStrip1, cline_strip *pStrip2)
bool	ForceMerge (cline_strip *pStrip1, cline_strip *pStrip2, double)
bool	OnBoundary (cline_strip *pStrip)
bool	SpecialCompactStripCase (double, double, double, double, double)
Protected Member Functions inherited from tools::ccontour
	ccontour (const ccontour &)
int	GetColFir () const
int	GetRowFir () const
int	GetColSec () const
int	GetRowSec () const
CFnStr *	FnctData (int i, int j)
double	Field (int x, int y)
void	Cntr1 (int x1, int x2, int y1, int y2)
void	Pass2 (int x1, int x2, int y1, int y2)

Additional Inherited Members
Static Protected Member Functions inherited from tools::ccontour
static void	_ASSERT_ (bool a_what, const char *a_where)
static void	_ASSERTP_ (void *a_what, const char *a_where)
Protected Attributes inherited from tools::ccontour
std::vector< double >	m_vPlanes
double	m_pLimits [4]
int	m_iColFir
int	m_iRowFir
int	m_iColSec
int	m_iRowSec
void *	m_pFieldFcnData
double(*	m_pFieldFcn )(double x, double y, void *)
double	m_dDx
double	m_dDy
CFnStr **	m_ppFnData

Detailed Description

Definition at line 25 of file clist_contour.

Constructor & Destructor Documentation

clist_contour() [1/2]

tools::clist_contour::clist_contour ( )

inline

Definition at line 111 of file clist_contour.

: ccontour()
{
}

~clist_contour()

virtual tools::clist_contour::~clist_contour ( )

inlinevirtual

Definition at line 34 of file clist_contour.

{CleanMemory();}

clist_contour() [2/2]

tools::clist_contour::clist_contour ( const clist_contour &  a_from )

inlineprotected

Definition at line 36 of file clist_contour.

:ccontour(a_from){}

Member Function Documentation

Area()

double tools::clist_contour::Area ( cline_strip *  Line )

inlineprotected

Definition at line 708 of file clist_contour.

{
    // if Line is not closed, return 0;
 
    double Ar = 0, x, y, x0,y0,x1, y1;
    int index;
 
    cline_strip::iterator pos;
    pos = Line->begin();
    index = (*pos);
    x0 = x =  get_xi(index);
    y0 = y =  get_yi(index);
 
    pos ++;
 
    for(;pos!=Line->end();pos++)
    {
        index = (*pos);
        x1 = get_xi(index);
        y1 = get_yi(index);
        // Ar += (x1-x)*(y1+y);
        Ar += (y1-y)*(x1+x)-(x1-x)*(y1+y);
        x = x1;
        y = y1;
 
    }
 
 
    //Ar += (x0-x)*(y0+y);
    Ar += (y0-y)*(x0+x)-(x0-x)*(y0+y);
    // if not closed curve, return 0;
    if ((x0-x)*(x0-x) + (y0-y)*(y0-y)>20*(m_dDx*m_dDx+m_dDy*m_dDy))
    {
        Ar = 0;
        _TRACE_(_TT("# open curve!\n"));
    }
    //else   Ar /= -2;
    else Ar/=4;
    // result is \int ydex/2 alone the implicit direction.
    return Ar;
}

CleanMemory()

void tools::clist_contour::CleanMemory ( )

inlineprotectedvirtual

Reimplemented from tools::ccontour.

Definition at line 153 of file clist_contour.

{
    ccontour::CleanMemory();
 
    cline_strip_list::iterator pos;
    cline_strip* pStrip;
    UINT i;
 
    // reseting lists
    for (i=0;i<m_vStripLists.size();i++) //G.Barrand
    {
        for (pos=m_vStripLists[i].begin(); pos!=m_vStripLists[i].end();pos++)
        {
            pStrip=(*pos);
            _ASSERTP_(pStrip,"clist_contour::CleanMemory");
            pStrip->clear();
            delete pStrip;
        }
        m_vStripLists[i].clear();
    }
}

compact_strips()

bool tools::clist_contour::compact_strips ( )

inline

Definition at line 374 of file clist_contour.

{
    cline_strip* pStrip;
    cline_strip* pStripBase = 0;
    UINT i;
    cline_strip_list::iterator pos,pos2;
    cline_strip_list newList;
    bool again, changed;
 
    const double weldDist = 10*(m_dDx*m_dDx+m_dDy*m_dDy);
 
    if(!_ASSERT_RET_(m_vStripLists.size() == get_number_of_planes(),"clist_contour::compact_strips ::0")) return false;
    for (i=0;i<get_number_of_planes();i++)
    {
        double planeHeight = get_plane(i);
        again=true;
        while(again)
        {
            // REPEAT COMPACT PROCESS UNTILL LAST PROCESS MAKES NO CHANGE
 
            again=false;
            // building compacted list
            if(!_ASSERT_RET_(newList.empty(),"clist_contour::compact_strips ::1")) return false;
            for (pos=m_vStripLists[i].begin(); pos!=m_vStripLists[i].end();pos++)
            {
                pStrip=(*pos);
                for (pos2=newList.begin(); pos2!=newList.end();pos2++)
                {
                    pStripBase=(*pos2);
                    changed=MergeStrips(pStripBase,pStrip);
                    if (changed)
                        again=true;
                    if (pStrip->empty())
                        break;
                }
                if (pStrip->empty())
                    delete pStrip;
                else
                    newList.insert(newList.begin(),pStrip);
            }
 
 
            // deleting old list
            m_vStripLists[i].clear();
            cline_strip* pStrip2;
            // Copying all
            for (pos2=newList.begin(); pos2 != newList.end(); pos2++)
            {
                pStrip2=(*pos2);
                cline_strip::iterator pos1 = pStrip2->begin(),pos3;
                while (pos1!=pStrip2->end())
                {
                    pos3 = pos1;
                    pos3++;
                    if (pos3==pStrip2->end()) break; //G.Barrand
                    if ( (*pos1) == (*pos3))
                    {
                      /*G.Barrand : we can't compare with pStrip2->end() content.
                        if ( (*pos3) != (*pStrip2->end()))
                            pStrip2->erase(pos3);
                        else
                        {
                            pStrip2->erase(pos3);
                            break;
                        }
                      */
                      pStrip2->erase(pos3); //G.Barrand.
                    }
                    else
                        pos1++;
                }
 
                //if (!(pStrip2->front()==pStrip2->back() && pStrip2->size()==2))
                if (pStrip2->size()!=1) 
                    m_vStripLists[i].insert(m_vStripLists[i].begin(),pStrip2 );
                else
                    delete pStrip2;
            }
            // emptying temp list
            newList.clear();
 
        } // OF WHILE(AGAIN) (LAST COMPACT PROCESS MADE NO CHANGES)
 
 
        if (m_vStripLists[i].empty())
            continue;
        // compact more
        int index,count;
        size_t Nstrip,j;
 
        Nstrip = m_vStripLists[i].size();
        std::vector<bool> closed(Nstrip);
        double x,y;
 
        // First let's find the open and closed lists in m_vStripLists
        for(pos2 = m_vStripLists[i].begin(), j=0, count=0; pos2 != m_vStripLists[i].end(); pos2++, j++)
        {
            pStrip = (*pos2);
 
            // is it open ?
            if (pStrip->front() != pStrip->back())
            {
                index = pStrip->front();
                x = get_xi(index); y = get_yi(index);
                index = pStrip->back();
                x -= get_xi(index); y -= get_yi(index);
 
                // is it "almost closed" ?
                if ((x*x+y*y < weldDist) ||
                                    SpecialCompactStripCase(get_xi(pStrip->front()), // L.Garnier
                                                            get_xi(pStrip->back()),
                                                            get_yi(pStrip->front()),
                                                            get_yi(pStrip->back()),
                                                            planeHeight))
                                {
                                        closed[j] = true;
                                        // close it !!! Added by L.Garnier
                                        pStrip->push_back(pStrip->front());
                                        //
                                }
                else
                {
                    closed[j] = false;
                    // updating not closed counter...
                    count ++;
                }
            }
            else
                closed[j] = true;
        }
 
        // is there any open strip ?
        if (count > 1)
        {
            // Merge the open strips into NewList
            pos = m_vStripLists[i].begin();
            for(j=0;j<Nstrip;j++)
            {
                if (closed[j] == false )
                {
                    pStrip = (*pos);
                    newList.insert(newList.begin(),pStrip);
                    pos = m_vStripLists[i].erase(pos);
                }
                else
                    pos ++;
            }
 
            // are they open strips to process ?
            while(newList.size()>1)
            {
                pStripBase = newList.front();
 
                // merge the rest to pStripBase
                again = true;
                while (again)
                {
                    again = false;
                    pos = newList.begin();
                    for(pos++; pos!=newList.end();)
                    {
                        pStrip = (*pos);
                        changed = ForceMerge(pStripBase,pStrip,planeHeight);
                        if (changed)
                        {
                            again = true;
                            delete pStrip;
                            pos = newList.erase(pos);
                        }
                        else
                            pos ++;
                    }
                } // while(again)
 
                index = pStripBase->front();
                x = get_xi(index); y = get_yi(index);
                index = pStripBase->back();
                x -= get_xi(index); y -= get_yi(index);
                // if pStripBase is closed or not
 
                if ((x*x+y*y < weldDist) ||
                                    SpecialCompactStripCase(get_xi(pStripBase->front()), // L.Garnier
                                                            get_xi(pStripBase->back()),
                                                            get_yi(pStripBase->front()),
                                                            get_yi(pStripBase->back()),
                                                            planeHeight))
                                {
 
                                  // close it !!! Added by L.Garnier
                                  if ((x!=0) || (y!=0)) {
                                    pStripBase->push_back(pStripBase->front());
                                  }
                                  //
                                  m_vStripLists[i].insert(m_vStripLists[i].begin(),pStripBase);
                                  newList.pop_front();
                }
                else
                {
                    if (OnBoundary(pStripBase))
                    {
                        _TRACE_(_TT("# open strip ends on boundary, continue.\n"));
                        m_vStripLists[i].insert(m_vStripLists[i].begin(),pStripBase);
                        newList.pop_front();
                    }
                    else
                    {
                        _PROBLEM_(_TT("unpaird open strip at 1!\n"));
                        //exit(0);
                        return false;
                    }
                }
            } // while(newList.size()>1);
 
 
            if (newList.size() ==1)
            {
                pStripBase = newList.front();
                index = pStripBase->front(); // L.Garnier
                x = get_xi(index); y = get_yi(index); // L.Garnier
                index = pStripBase->back(); // L.Garnier
                x -= get_xi(index); y -= get_yi(index); // L.Garnier
 
                // is it "almost closed", give last chance...5*weldDist
                if (x*x+y*y < 3*weldDist) // L.Garnier
                {
                    m_vStripLists[i].insert(m_vStripLists[i].begin(),pStripBase);
                    newList.pop_front();
                }
                else if (OnBoundary(pStripBase))
                {
                    _TRACE_(_TT("# open strip ends on boundary, continue.\n"));
                    m_vStripLists[i].insert(m_vStripLists[i].begin(),pStripBase);
                    newList.pop_front();
                }
                else
                {
                    _PROBLEM_(_TT("unpaird open strip at 2!\n"));
                    DumpPlane(i);
                    //exit(0);
                    return false;
                }
            }
 
            newList.clear();
 
        }
        else if (count == 1)
        {
            pos = m_vStripLists[i].begin();
            for(j=0;j<Nstrip;j++)
            {
                if (closed[j] == false )
                {
                    pStripBase = (*pos);
                    break;
                }
                pos ++;
            }
            index = pStripBase->front(); // L.Garnier
            x = get_xi(index); y = get_yi(index); // L.Garnier
            index = pStripBase->back(); // L.Garnier
            x -= get_xi(index); y -= get_yi(index); // L.Garnier
       
            // is it "almost closed", give last chance...5*weldDist
            if (x*x+y*y < 2*weldDist) // L.Garnier
            {
              //close it!!
              pStripBase->push_back(pStripBase->front()); // L.Garnier
            }
            else if (OnBoundary(pStripBase))
            {
                _TRACE_(_TT("# open strip ends on boundary, continue.\n"));
                pStripBase->push_back(pStripBase->front()); // L.Garnier
            }
            else
            {
                _TRACE_(_TT("unpaird open strip at 3!"));
                DumpPlane(i);
                return false;  // L.Garnier
                //exit(0);
            }
            newList.clear();  // L.Garnier
        }
    }
        return true;
}

DumpPlane()

void tools::clist_contour::DumpPlane ( unsigned int  iPlane ) const

inlineprotected

debuggin

Definition at line 686 of file clist_contour.

{
    cline_strip_list::const_iterator pos;
    UINT i;
    cline_strip* pStrip;
 
    /*_ASSERT_(iPlane>=0,"clist_contour::DumpPlane");*/
    _ASSERT_(iPlane<get_number_of_planes(),"clist_contour::DumpPlane::0");
    _TRACE_(_TT("Level : %d"),get_plane(iPlane));
 
    _TRACE_(_TT("Number of strips : %d\r\n"),m_vStripLists[iPlane].size());
    _TRACE_(_TT("i np start end xstart ystart xend yend\r\n"));
    for (pos = m_vStripLists[iPlane].begin(), i=0; pos != m_vStripLists[iPlane].end(); pos++, i++)
    {
        pStrip=*pos;
        _ASSERTP_(pStrip,"clist_contour::DumpPlane::1");
        _TRACE_(_TT("%d %d %d %d %g %g %g %g\r\n"),i,pStrip->size(),pStrip->front(),pStrip->back(),
            get_xi(pStrip->front()),get_yi(pStrip->front()),
            get_xi(pStrip->back()),get_yi(pStrip->back()) );
    }
}

EdgeWeight()

double tools::clist_contour::EdgeWeight ( cline_strip *  pLine, double  R  )

inlineprotected

Definition at line 750 of file clist_contour.

{
    cline_strip::iterator pos;
    int count = 0,index;
    double x,y;
    for(pos = pLine->begin(); pos!=pLine->end(); pos++)
    {
        index = (*pos);
        x = get_xi(index);
        y = get_yi(index);
        if (fabs(x) > R || fabs(y) > R)
            count ++;
    }
    return (double)count/pLine->size();
}

ExportLine()

void tools::clist_contour::ExportLine ( int  iPlane, int  x1, int  y1, int  x2, int  y2  )

inlinevirtual

Implements tools::ccontour.

Definition at line 175 of file clist_contour.

{
    _ASSERT_(iPlane>=0,"clist_contour::ExportLine::0");
    _ASSERT_(iPlane<(int)get_number_of_planes(),"clist_contour::ExportLine::1");
 
    // check that the two points are not at the beginning or end of the  some line strip
    UINT i1=y1*(m_iColSec+1)+x1;
    UINT i2=y2*(m_iColSec+1)+x2;
 
    cline_strip* pStrip;
 
    cline_strip_list::iterator pos;
    bool added = false;
    for(pos=m_vStripLists[iPlane].begin(); pos!=m_vStripLists[iPlane].end() && !added; pos++)
    {
        pStrip=(*pos);
        _ASSERTP_(pStrip,"clist_contour::ExportLine::2");
        // check if points are appendable to this strip
        if (i1==pStrip->front())
        {
            pStrip->insert(pStrip->begin(),i2);
            return;
        }
        if (i1==pStrip->back())
        {
            pStrip->insert(pStrip->end(),i2);
            return;
        }
        if (i2==pStrip->front())
        {
            pStrip->insert(pStrip->begin(),i1);
            return;
        }
        if (i2==pStrip->back())
        {
            pStrip->insert(pStrip->end(),i1);
            return;
        }
    }
 
    // segment was not part of any line strip, creating new one
    pStrip=new cline_strip;
    pStrip->insert(pStrip->begin(),i1);
    pStrip->insert(pStrip->end(),i2);
    m_vStripLists[iPlane].insert(m_vStripLists[iPlane].begin(),pStrip);
}

ForceMerge()

bool tools::clist_contour::ForceMerge ( cline_strip *  pStrip1, cline_strip *  pStrip2, double  aHeight  )

inlineprotected

Definition at line 222 of file clist_contour.

{
 
    cline_strip::iterator pos;
    cline_strip::reverse_iterator rpos;
 
    if (pStrip2->empty())
        return false;
 
    double x[4], y[4], weldDist;
    int index;
    index = pStrip1->front();
    x[0] = get_xi(index);
    y[0] = get_yi(index);
    index = pStrip1->back();
    x[1] = get_xi(index);
    y[1] = get_yi(index);
    index = pStrip2->front();
    x[2] = get_xi(index);
    y[2] = get_yi(index);
    index = pStrip2->back();
    x[3] = get_xi(index);
    y[3] = get_yi(index);
 
    weldDist = 10*(m_dDx*m_dDx+m_dDy*m_dDy);
 
    if (((x[1]-x[2])*(x[1]-x[2])+(y[1]-y[2])*(y[1]-y[2])< weldDist)
            || SpecialCompactStripCase(x[1],x[2],y[1],y[2],aHeight)) // L.Garnier
 
    {
        for (pos=pStrip2->begin(); pos!=pStrip2->end();pos++)
        {
            index=(*pos);
            if(!_ASSERT_RET_(index>=0,"clist_contour::ForceMerge::0")) return false;
            pStrip1->insert(pStrip1->end(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    if (((x[3]-x[0])*(x[3]-x[0])+(y[3]-y[0])*(y[3]-y[0])< weldDist)
            || SpecialCompactStripCase(x[3],x[0],y[3],y[0],aHeight)) // L.Garnier
    {
        for (rpos=pStrip2->rbegin(); rpos!=pStrip2->rend();rpos++)
        {
            index=(*rpos);
            if(!_ASSERT_RET_(index>=0,"clist_contour::ForceMerge::1")) return false;
            pStrip1->insert(pStrip1->begin(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    if (((x[1]-x[3])*(x[1]-x[3])+(y[1]-y[3])*(y[1]-y[3])< weldDist)
            || SpecialCompactStripCase(x[1],x[3],y[1],y[3],aHeight)) // L.Garnier
    {
        for (rpos=pStrip2->rbegin(); rpos!=pStrip2->rend();rpos++)
        {
            index=(*rpos);
            if(!_ASSERT_RET_(index>=0,"clist_contour::ForceMerge::2")) return false;
            pStrip1->insert(pStrip1->end(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    if (((x[0]-x[2])*(x[0]-x[2])+(y[0]-y[2])*(y[0]-y[2])< weldDist)
            || SpecialCompactStripCase(x[0],x[2],y[0],y[2],aHeight)) // L.Garnier
    {
        for (pos=pStrip2->begin(); pos!=pStrip2->end();pos++)
        {
            index=(*pos);
            if(!_ASSERT_RET_(index>=0,"clist_contour::ForceMerge::3")) return false;
            pStrip1->insert(pStrip1->begin(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    return false;
}

generate()

void tools::clist_contour::generate ( )

inlinevirtual

Reimplemented from tools::ccontour.

Definition at line 116 of file clist_contour.

{
    // generate line strips
    ccontour::generate();
    // compact strips
    compact_strips ();
}

get_lines()

cline_strip_list * tools::clist_contour::get_lines ( unsigned int  iPlane )

inline

Definition at line 796 of file clist_contour.

                                                                        {
  /*_ASSERT_(iPlane>=0);*/
  _ASSERT_(iPlane<get_number_of_planes(),"clist_contour::get_lines");
  return &m_vStripLists[iPlane];
}

InitMemory()

void tools::clist_contour::InitMemory ( )

inlineprotectedvirtual

Reimplemented from tools::ccontour.

Definition at line 124 of file clist_contour.

{
    ccontour::InitMemory();
 
    cline_strip_list::iterator pos;
    cline_strip* pStrip;
 
    if (!m_vStripLists.empty())
    {
        UINT i;
        // reseting lists
        _ASSERT_(m_vStripLists.size() == get_number_of_planes(),"clist_contour::InitMemory::0");
        for (i=0;i<get_number_of_planes();i++)
        {
            for (pos = m_vStripLists[i].begin(); pos!=m_vStripLists[i].end() ; pos++)
            {
                pStrip=(*pos);
                _ASSERTP_(pStrip,"clist_contour::InitMemory::1");
 
                pStrip->clear();
                delete pStrip;
            }
            m_vStripLists[i].clear();
        }
    }
    else
        m_vStripLists.resize(get_number_of_planes());
}

MergeStrips()

bool tools::clist_contour::MergeStrips ( cline_strip *  pStrip1, cline_strip *  pStrip2  )

inlineprotected

Definition at line 304 of file clist_contour.

{
    cline_strip::iterator pos;
    cline_strip::reverse_iterator rpos;
    if (pStrip2->empty())
        return false;
 
    int index;
 
    // debugging stuff
    if (pStrip2->front()==pStrip1->front())
    {
        // retreiving first element
        pStrip2->pop_front();
        // adding the rest to strip1
        for (pos=pStrip2->begin(); pos!=pStrip2->end();pos++)
        {
            index=(*pos);
            if(!_ASSERT_MERGE_RET_(index>=0,"clist_contour::MergeStrips::0",pStrip2)) return false;
            pStrip1->insert(pStrip1->begin(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    if (pStrip2->front()==pStrip1->back())
    {
        pStrip2->pop_front();
        // adding the rest to strip1
        for (pos=pStrip2->begin(); pos!=pStrip2->end();pos++)
        {
            index=(*pos);
            if(!_ASSERT_MERGE_RET_(index>=0,"clist_contour::MergeStrips::1",pStrip2)) return false;
            pStrip1->insert(pStrip1->end(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    if (pStrip2->back()==pStrip1->front())
    {
        pStrip2->pop_back();
        // adding the rest to strip1
        for (rpos=pStrip2->rbegin(); rpos!=pStrip2->rend();rpos++)
        {
            index=(*rpos);
            if(!_ASSERT_MERGE_RET_(index>=0,"clist_contour::MergeStrips::2",pStrip2)) return false;
            pStrip1->insert(pStrip1->begin(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    if (pStrip2->back()==pStrip1->back())
    {
        pStrip2->pop_back();
        // adding the rest to strip1
        for (rpos=pStrip2->rbegin(); rpos!=pStrip2->rend();rpos++)
        {
            index=(*rpos);
            if(!_ASSERT_MERGE_RET_(index>=0,"clist_contour::MergeStrips::3",pStrip2)) return false;
            pStrip1->insert(pStrip1->end(),index);
        }
        pStrip2->clear();
        return true;
    }
 
    return false;
}

OnBoundary()

bool tools::clist_contour::OnBoundary ( cline_strip *  pStrip )

inlineprotected

Definition at line 663 of file clist_contour.

{
    bool e1,e2;
 
    int index = pStrip->front();
    double x = get_xi(index), y = get_yi(index);
    if (x==m_pLimits[0] || x == m_pLimits[1] ||
        y == m_pLimits[2] || y == m_pLimits[3])
        e1 = true;
    else
        e1 = false;
 
    index = pStrip->back();
    x = get_xi(index); y = get_yi(index);
    if (x==m_pLimits[0] || x == m_pLimits[1] ||
        y == m_pLimits[2] || y == m_pLimits[3])
        e2 = true;
    else
        e2 = false;
 
    return (e1 && e2);
}

SpecialCompactStripCase()

bool tools::clist_contour::SpecialCompactStripCase ( double  aXfront, double  aXback, double  aYfront, double  aYback, double  actualHeight  )

inlineprotected

Definition at line 803 of file clist_contour.

{
  // To solve the case of a list of strips
  // which appeared to be open but should correspond to a closed
  // contour.
  //  With the today generate() algorithm, it appears that we fall
  // on this case when the begin and end points
  // are on a horizontal or vertical line.
  // (case where front()->x == back()->x or front()->y == back()->y).
  //  We try to detect in this method this situation and decide to close
  // or not the line. To do that we check the heigth of intermediate
  // points to see if there are on the same contour; if so we close
  // the line (and return true), if not we do nothing (and return false).
 
  // check if we could realy close it
  float marge = 1; // *m_dDy or *m_dDx. 1 seems to be good and normal, but why
                   // not 2 in certain cases???
 
  double distToNext =0;
  // try to get the correct hight
  if (get_plane(0)>= actualHeight) {
    return false;
  }
  if (get_number_of_planes() >1){
    distToNext = get_plane(1)-get_plane(0);
  } else {
    return false;
  }
 
  if ((aYback-aYfront) == 0) {
    double temp;
    double av;
    double eg;
    double ap;
 
    if (aXfront==m_pLimits[0] && aXback == m_pLimits[1]) return false;
    if (aXfront==m_pLimits[1] && aXback == m_pLimits[0]) return false;
 
    if (aXfront > aXback ) {
      temp = aXfront;
      aXfront = aXback;
      aXback = temp;
    }
    for(double check=aXfront+m_dDx;
        check<aXback;
        check+=m_dDx) {
      av = ((*m_pFieldFcn)(check,aYback-marge*m_dDy,m_pFieldFcnData)-actualHeight);
      eg = ((*m_pFieldFcn)(check,aYback,m_pFieldFcnData)-actualHeight);
      ap = ((*m_pFieldFcn)(check,aYback+marge*m_dDy,m_pFieldFcnData)-actualHeight);
 
      if ((av>distToNext) && (ap>distToNext) && (eg>distToNext)) {
        return false;
      } else if ((av<0) && (ap<0) && (eg<0)) {
        return false;
      }
    }
    return true;
  } else if ((aXback-aXfront) == 0) {
    double temp;
    double av;
    double eg;
    double ap;
    if (aYfront==m_pLimits[3] && aYback == m_pLimits[2]) return false;
    if (aYfront==m_pLimits[2] && aYback == m_pLimits[3]) return false;
 
    if (aYfront > aYback ) {
      temp = aYfront;
      aYfront = aYback;
      aYback = temp;
    }
 
    for(double check=aYfront+m_dDy;
        check<aYback;
        check+=m_dDy) {
      av = ((*m_pFieldFcn)(aXback-marge*m_dDx,check,m_pFieldFcnData)-actualHeight);
      eg = ((*m_pFieldFcn)(aXback,check,m_pFieldFcnData)-actualHeight);
      ap = ((*m_pFieldFcn)(aXback+marge*m_dDx,check,m_pFieldFcnData)-actualHeight);
      if ((av>distToNext) && (ap>distToNext) && (eg>distToNext)) {
        return false;
      } else if ((av<0) && (ap<0) && (eg<0)) {
        return false;
      }
    }
    return true;
  }
  return false;
}

---

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

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/clist_contour