CompositeSurface.h

//===========================================================================
// GoTools - SINTEF Geometry Tools version 1.1
//
// GoTools module: CORE
//
// 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 _COMPOSITESURFACE_H
#define _COMPOSITESURFACE_H

#include "SplineSurface.h"

namespace Go
{


    class CompositeSurface : public ParamSurface
    {
    public:
        CompositeSurface()
        {}
        CompositeSurface(const std::vector<SplineSurface>& domain_maps,
                         const SplineSurface& surf)
            : surf_(surf), domain_maps_(domain_maps)
        {
            int num_maps = domain_maps.size();
            for (int i = 0; i < num_maps; ++i) {
                ASSERT(domain_maps_[i].dimension() == 2);
            }
        }

        virtual void read (std::istream& is)
        {
            surf_.read(is);
            int num_maps;
            is >> num_maps;
            domain_maps_.resize(num_maps);
            for (int i = 0; i < num_maps; ++i) {
                domain_maps_[i].read(is);
            }
        }
        virtual void write (std::ostream& os) const
        {
            surf_.write(os);
            int num_maps = domain_maps_.size();
            os << num_maps << '\n';
            for (int i = 0; i < num_maps; ++i) {
                domain_maps_[i].write(os);
            }
        }

        virtual BoundingBox boundingBox() const
        { return surf_.boundingBox(); }

        virtual int dimension() const
        { return surf_.dimension(); }

        virtual ClassType instanceType() const
        { return CompositeSurface::classType(); }

        static ClassType classType()
        { return Class_CompositeSurface; }


        virtual ~CompositeSurface()
        {}

        virtual CompositeSurface* clone() const
        { return new CompositeSurface(*this); }
        virtual const RectDomain& parameterDomain() const
        { return domain_maps_.front().parameterDomain(); }

        virtual RectDomain containingDomain() const
        { return domain_maps_.front().parameterDomain(); }

        void setParameterDomain(double u1, double u2, double v1, double v2)
        { domain_maps_.front().setParameterDomain(u1, u2, v1, v2); }


        virtual CurveLoop outerBoundaryLoop(double degenerate_epsilon
                                            = DEFAULT_SPACE_EPSILON) const
        { THROW("Not implemented");return surf_.outerBoundaryLoop(degenerate_epsilon); }

        virtual std::vector<CurveLoop> allBoundaryLoops(double degenerate_epsilon
                                                        = DEFAULT_SPACE_EPSILON) const
        { THROW("Not implemented");return surf_.allBoundaryLoops(degenerate_epsilon); }

        virtual DirectionCone normalCone() const
        { THROW("Not implemented");return surf_.normalCone(); }
    
        virtual DirectionCone tangentCone(bool pardir_is_u) const
        { THROW("Not implemented");return surf_.tangentCone(pardir_is_u); }

        virtual CompositeBox compositeBox() const
        { THROW("Not implemented");return surf_.compositeBox(); }
   
        virtual void point(Point& pt, double upar, double vpar) const
        {
            Point param(2);
            param[0] = upar;
            param[1] = vpar;
            Point param_next(2);
            int num_maps = domain_maps_.size();
            for (int i = 0; i < num_maps; ++i) {
                domain_maps_[i].point(param_next, param[0], param[1]);
                param = param_next;
            }
            surf_.point(pt, param[0], param[1]);
        }

        virtual void point(std::vector<Point>& pts, 
                           double upar, double vpar,
                           int derivs,
                           bool u_from_right = true,
                           bool v_from_right = true,
                           double resolution = 1.0e-12) const
        { THROW("Not implemented"); }

        virtual void normal(Point& n, double upar, double vpar) const
        {
            Point param(2);
            param[0] = upar;
            param[1] = vpar;
            Point param_next(2);
            int num_maps = domain_maps_.size();
            for (int i = 0; i < num_maps; ++i) {
                domain_maps_[i].point(param_next, param[0], param[1]);
                param = param_next;
            }
            surf_.normal(n, param[0], param[1]);
        }

        virtual std::vector<boost::shared_ptr<ParamCurve> >
        constParamCurves(double parameter, bool pardir_is_u) const
        { THROW("Not implemented"); }

        virtual std::vector<boost::shared_ptr<ParamSurface> >
        subSurfaces(double from_upar, double from_vpar,
                    double to_upar, double to_vpar,
                    double fuzzy = DEFAULT_PARAMETER_EPSILON) const
        { THROW("Not implemented"); }

        virtual double nextSegmentVal(int dir, double par, bool forward, double tol) const
        { THROW("Not implemented"); }

        virtual void closestPoint(const Point& pt,
                                  double&        clo_u,
                                  double&        clo_v, 
                                  Point&       clo_pt,
                                  double&        clo_dist,
                                  double         epsilon,
                                  const RectDomain* domain_of_interest = NULL,
                                  double   *seed = 0) const
        { THROW("Not implemented"); }


        virtual void closestBoundaryPoint(const Point& pt,
                                          double&        clo_u,
                                          double&        clo_v, 
                                          Point&       clo_pt,
                                          double&        clo_dist,
                                          double epsilon,
                                          const RectDomain* rd = NULL,
                                          double *seed = 0) const
        { THROW("Not implemented"); }

        virtual void getBoundaryInfo(Point& pt1, Point& pt2,
                                     double epsilon, SplineCurve*& cv,
                                     SplineCurve*& crosscv, double knot_tol = 1e-05) const
        { THROW("Not implemented"); }

        virtual void turnOrientation()
        { THROW("Not implemented"); }

        virtual void reverseParameterDirection(bool direction_is_u)
        { THROW("Not implemented"); }

        virtual void swapParameterDirection()
        { THROW("Not implemented"); }


        virtual bool isDegenerate(bool& b, bool& r,
                                  bool& t, bool& l, double tolerance) const
        { THROW("Not implemented"); }

    private:
        SplineSurface surf_;
        std::vector<SplineSurface> domain_maps_;
    };


} // namespace Go



#endif // _COMPOSITESURFACE_H

---