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_