BicubicSurface.h

Go to the documentation of this file.

#ifndef SimTK_BICUBIC_SURFACE_H_
#define SimTK_BICUBIC_SURFACE_H_
 
/* -------------------------------------------------------------------------- *
 *                        Simbody(tm): SimTKmath                              *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2011-12 Stanford University and the Authors.        *
 * Authors: Matthew Millard, Michael Sherman                                  *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */
 
#include "SimTKcommon.h"
#include "simmath/internal/common.h"
#include "simmath/internal/Geo.h"
#include "simmath/internal/Geo_BicubicHermitePatch.h"
#include "simmath/internal/Geo_BicubicBezierPatch.h"
 
#include <limits>
 
namespace SimTK { 
 
//==============================================================================
//                           CLASS BICUBIC SURFACE
//==============================================================================
class SimTK_SIMMATH_EXPORT BicubicSurface {
public:   
    class PatchHint; // See below for definition of PatchHint.
 
    BicubicSurface() : guts(0) {}
    ~BicubicSurface();
    BicubicSurface(const BicubicSurface& source);
    BicubicSurface& operator=(const BicubicSurface& source);
 
    
    BicubicSurface(const Vector& x, const Vector& y, const Matrix& f, 
                   Real smoothness=0);
 
    BicubicSurface(const Vec2& XY, const Vec2& spacing, 
                   const Matrix& f, Real smoothness=0);
 
    Real calcValue(const Vec2& XY, PatchHint& hint) const;
 
    Real calcValue(const Vec2& XY) const;
 
    UnitVec3 calcUnitNormal(const Vec2& XY, PatchHint& hint) const;
 
    UnitVec3 calcUnitNormal(const Vec2& XY) const;
    
    Real calcDerivative(const Array_<int>& derivComponents, 
                        const Vec2& XY, PatchHint& hint) const;
 
    Real calcDerivative(const Array_<int>& derivComponents, 
                        const Vec2& XY) const;
    
    bool isSurfaceDefined(const Vec2& XY) const;
 
    Vec2 getMinXY() const;
    Vec2 getMaxXY() const;
 
    PolygonalMesh createPolygonalMesh(Real resolution=1) const;
 
    //--------------------------------------------------------------------------
    int getNumAccesses() const;
    int getNumAccessesSamePoint() const;
    int getNumAccessesSamePatch() const;
    int getNumAccessesNearbyPatch() const;
    void resetStatistics() const;
    //--------------------------------------------------------------------------
    BicubicSurface(const Vector& x, const Vector& y, const Matrix& f, 
                   const Matrix& fx, const Matrix& fy, const Matrix& fxy);
    BicubicSurface(const Vec2& XY, const Vec2& spacing, const Matrix& f, 
                   const Matrix& fx, const Matrix& fy, const Matrix& fxy);
 
    void calcParaboloid(const Vec2& XY, PatchHint& hint, 
                        Transform& X_SP, Vec2& k) const;
    void calcParaboloid(const Vec2& XY, Transform& X_SP, Vec2& k) const;
 
    void getNumPatches(int& nx, int& ny) const;
 
    Geo::BicubicHermitePatch calcHermitePatch(int x, int y) const;
 
    Geo::BicubicBezierPatch calcBezierPatch(int x, int y) const;
    //--------------------------------------------------------------------------
    bool isEmpty() const {return guts==0;}
 
    void clear(); // Hide from Doxygen.    
    class Guts; // Opaque implementation class.
    const BicubicSurface::Guts& getGuts() const
    {   assert(guts); return *guts; }
private:
    BicubicSurface::Guts* guts;
};    // END class BicubicSurface
 
 
 
//==============================================================================
//                 CLASS BICUBIC FUNCTION :: PATCH HINT
//==============================================================================
class SimTK_SIMMATH_EXPORT BicubicSurface::PatchHint {
public:
    PatchHint();
    PatchHint(const PatchHint& source);
    PatchHint& operator=(const PatchHint& source);
    ~PatchHint();
 
    bool isEmpty() const;
    void clear();
 // Hide from Doxygen
    class Guts; // Hidden implementation of PatchHint.
    const Guts& getGuts() const {return *guts;}
    Guts&       updGuts()       {return *guts;}
private:
    Guts* guts;
};
 
 
 
//==============================================================================
//                           CLASS BICUBIC FUNCTION
//==============================================================================
 
class SimTK_SIMMATH_EXPORT BicubicFunction : public Function_<Real> {
public:
    BicubicFunction(const BicubicSurface& surface) : surface(surface) {}
 
    const BicubicSurface& getBicubicSurface() const {return surface;}
 
    Real calcValue(const Vector& XY) const override {
        SimTK_ERRCHK1(XY.size()==2, "BicubicFunction::calcValue()",
        "The argument Vector XY must have exactly 2 elements but had %d.",
        XY.size());        
        return surface.calcValue(Vec2(XY[0],XY[1]), hint); 
    }
    
    Real calcDerivative(const Array_<int>& derivComponents, 
                        const Vector& XY) const override {
        SimTK_ERRCHK1(XY.size()==2, "BicubicFunction::calcDerivative()",
        "The argument Vector XY must have exactly 2 elements but had %d.",
        XY.size());        
        return surface.calcDerivative(derivComponents, Vec2(XY[0],XY[1]), hint); 
    }
 
    int getArgumentSize() const override {return 2;}
 
    int getMaxDerivativeOrder() const override 
    {   return std::numeric_limits<int>::max(); }
 
    BicubicFunction* clone() const override {return new BicubicFunction(*this);}
 
    Real calcDerivative(const std::vector<int>& derivComponents, 
                        const Vector& x) const 
    {   return calcDerivative(ArrayViewConst_<int>(derivComponents),x); }
 
private:
    BicubicSurface                      surface;
    mutable BicubicSurface::PatchHint   hint;
};
 
 
 
}; //namespace
//=============================================================================
//=============================================================================
 
#endif  // SimTK_BICUBIC_SURFACE_H_