NurbsSurface.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#ifndef MERCURYDPM_NURBSSURFACE_H
#define MERCURYDPM_NURBSSURFACE_H
 
#include <vector>
#include <array>
#include "Math/Vector.h"
 
class NurbsSurface
{
public:
    NurbsSurface();
    
    NurbsSurface(const std::vector<double>& knotsU, const std::vector<double>& knotsV,
                 const std::vector<std::vector<Vec3D>>& controlPoints,
                 const std::vector<std::vector<double>>& weights);
    
    NurbsSurface(const std::vector<std::vector<Vec3D>>& controlPoints,
                 const std::vector<std::vector<Mdouble>>& weights,
                 unsigned int degreeU, unsigned int degreeV,
                 bool clampedAtStartU = true, bool clampedAtEndU = true,
                 bool clampedAtStartV = true, bool clampedAtEndV = true);
    
    Vec3D evaluate(double u, double v) const;
 
    void evaluateDerivatives(double u, double v, std::array<std::array<Vec3D,3>,3>& S) const;
 
    bool getDistance(Vec3D P, double radius, double& distance, Vec3D& normal) const;
    
    void set(const std::vector<double>& knotsU, const std::vector<double>& knotsV,
             const std::vector<std::vector<Vec3D>>& controlPoints, const std::vector<std::vector<double>>& weights);
 
    void setClosedInU(bool closedInU);
 
    void setClosedInV(bool closedInV);
 
    void flipOrientation();
 
    void closestPoint(Vec3D position, double& u, double& v) const;
 
    void splitSurface (int spanU, int spanV) {
 
    }
 
    friend std::ostream& operator<<(std::ostream& os, const NurbsSurface& a);
 
    friend std::istream& operator>>(std::istream& is, NurbsSurface& a);
    
    double getLowerBoundU() const{
        return knotsU_[degreeU_];
    }
    double getUpperBoundU() const{
        return knotsU_[knotsU_.size() - degreeU_ - 1]; // same as knotsU_[controlPoints.size()];
    }
    double getLowerBoundV() const{
        return knotsV_[degreeV_];
    }
    double getUpperBoundV() const{
        return knotsV_[knotsV_.size() - degreeV_ - 1]; // same as knotsV_[controlPoints[0].size()];
    }
    
    const std::vector<std::vector<Vec3D>>& getControlPoints() const
    { return controlPoints_; }
    
    const std::vector<std::vector<Mdouble>>& getWeights() const
    { return weights_; }
    
    const std::vector<Mdouble>& getKnotsU() const
    { return knotsU_; }
    
    const std::vector<Mdouble>& getKnotsV() const
    { return knotsV_; }
    
    void makePeriodicContinuousInU();
    
    void makePeriodicContinuousInV();
    
    void makeClosedInU();
    
    void makeClosedInV();
    
    void unclampKnots(bool inU, bool atStart);
    
    void moveControlPoint(unsigned int indexU, unsigned int indexV, Vec3D dP, bool includingClosedOrPeriodic);
 
private:
    std::vector<Mdouble> knotsU_;
    std::vector<Mdouble> knotsV_;
    std::vector<std::vector<Vec3D>> controlPoints_;
    std::vector<std::vector<Mdouble>> weights_;
    unsigned int degreeU_, degreeV_;
    bool closedInU_, closedInV_;
    // For when using periodic boundaries and the surface is extended to make it continuous
    bool periodicInU_, periodicInV_;
    
    // Storing starting points for a quick start of the getDistance method
    std::vector<Vec3D> startingPoints_;
    std::vector<Mdouble> startingKnotsU_;
    std::vector<Mdouble> startingKnotsV_;
    
    void wrapAroundInU(unsigned int numStartToEnd, unsigned int numEndToStart, bool forceBothEndsUniform = false);
    
    void wrapAroundInV(unsigned int numStartToEnd, unsigned int numEndToStart, bool forceBothEndsUniform = false);
};
 
#endif //MERCURYDPM_NURBSSURFACE_H