SingularityInfo.h

//===========================================================================
// GoTools - SINTEF Geometry Tools
//
// GoTools module: Intersections, version 1.0
//
// Copyright (C) 2000-2007 SINTEF ICT, Applied Mathematics, Norway.
//
// This program is free software; you can redistribute it and/or          
// modify it under the terms of the GNU General Public License            
// as published by the Free Software Foundation version 2 of the License. 
//
// This program is distributed in the hope that it will be useful,        
// but WITHOUT ANY WARRANTY; without even the implied warranty of         
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          
// GNU General Public License for more details.                           
//
// You should have received a copy of the GNU General Public License      
// along with this program; if not, write to the Free Software            
// Foundation, Inc.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: E-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//===========================================================================
#ifndef _SINGULARITYINFO_H
#define _SINGULARITYINFO_H


#include "Point.h"
#include <vector>
#include <boost/shared_ptr.hpp>


namespace Go {




class SingularityInfo {
public:
    SingularityInfo();

    SingularityInfo(boost::shared_ptr<SingularityInfo> previous,
                    bool use_previous = false);

    SingularityInfo(boost::shared_ptr<SingularityInfo> previous,
                    int missing_dir);

    bool hasPoint()
    { return (param_sing_.size() > 0); }

    int getNmbPoints(int nmb_par)
    { return param_sing_.size()/nmb_par; }

    double getParam(int dir);

    void addIterationCount()
    { 
        nmb_iter_++; 
        iteration_done_ = true;
    }

    void addSimpleCount(bool simple1, bool simple2)
    {
        if (simple1)
            nmb_simple1_++;
        if (simple2)
            nmb_simple2_++;
    }

    void setSingularPoint(double* par, int nmb_par);

    void addSingularPoint(double* par, int nmb_par);

    Point getPoint(int idx, int nmb_par);

    bool iterationDone()
    { return iteration_done_; }

    bool iterationSucceed()
    { return iteration_succeed_; }

    int nmbSimple1()
    { return nmb_simple1_; }

    int nmbSimple2()
    { return nmb_simple2_; }

    void setHighPriSing(double* par, int nmb_par);

    void setHighPriSingType(SingularityClassification type)
    { high_pri_type_ = type; }
                  
    SingularityClassification hasHighPriSing()
    { return (high_pri_sing_.size() == 0) ? NO_SING : high_pri_type_; }

    double getHighPriSing(int idx)
    { return high_pri_sing_[idx]; }

    std::vector<double> getHighPriSing()
    { return high_pri_sing_; }

    // Remove singularities outside the current domain
    void cleanUp(std::vector<double> start,
                 std::vector<double> end,
                 double tol);

private:
    // Data members

    // Number of iterations for singularity or closest point performed
    // downward in the recursion
    int nmb_iter_;   

    // How often this iteration has succeeded
    int nmb_success_;

    // How often the first intersection object is characterized as
    // simple (only relevant in surface-surface intersection)
    int nmb_simple1_;

    // How often the second intersection object (if any) is
    // characterized as simple (only relevant in surface-surface
    // intersection)
    int nmb_simple2_;

    // Last found singularity or closest point (parameter values)
    std::vector<double> param_sing_;

    // If any iteration for singularity or closest point is performed
    // at this recursion level
    bool iteration_done_;

    // If the last iteration found a singularity
    bool iteration_succeed_;

    // Existence of high priority singularity
    SingularityClassification high_pri_type_;

    // Parameter of high priority singularity
    std::vector<double> high_pri_sing_;
};


} // namespace Go


#endif // _SINGULARITYINFO_H

---