NurbsSurface.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#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