opennurbs_offsetsurface.h

/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//              
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/

#if !defined(ON_OFFSETSURFACE_INC_)
#define ON_OFFSETSURFACE_INC_

class ON_CLASS ON_BumpFunction
{
public:
  ON_BumpFunction();
  ~ON_BumpFunction() = default;
  ON_BumpFunction(const ON_BumpFunction&) = default;
  ON_BumpFunction& operator=(const ON_BumpFunction&) = default;

public:
  double ValueAt(
    double s,
    double t
    ) const;

  void Evaluate(
    double s,
    double t,
    int der_count,
    double* value
    ) const;

public:
  ON_2dPoint m_point = ON_2dPoint::NanPoint; // center of bump
  int m_type[2];//  // = {0,0}  // 1 = linear, 5 = quintic, else linear;

public:
  // numbers used in evaluation
  double m_x0 = 0.0;
  double m_y0 = 0.0;
  double m_sx[2]; // = {0.0, 0.0} // 1/(support radius)
  double m_sy[2]; // = {0.0, 0.0} // 1/(support radius)
  double m_a = 0.0;  // evaluation coefficient

private:
  void Internal_EvaluateLinearBump(double t, double dt, int der_count, double* value) const;
  void Internal_EvaluateQuinticBump(double t, double dt, int der_count, double* value) const;
};


class ON_CLASS ON_OffsetSurfaceValue
{
public:
  ON_OffsetSurfaceValue() = default;
  ~ON_OffsetSurfaceValue() = default;
  ON_OffsetSurfaceValue(const ON_OffsetSurfaceValue&) = default;
  ON_OffsetSurfaceValue& operator=(const ON_OffsetSurfaceValue&) = default;
public:
  double m_s = ON_DBL_QNAN;
  double m_t = ON_DBL_QNAN;
  double m_distance = ON_DBL_QNAN;
  double m_radius = ON_DBL_QNAN;
  int m_index = ON_UNSET_INT_INDEX;
};


#if defined(ON_DLL_TEMPLATE)
ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray<ON_BumpFunction>;
ON_DLL_TEMPLATE template class ON_CLASS ON_SimpleArray<ON_OffsetSurfaceValue>;
#endif


class ON_CLASS ON_OffsetSurfaceFunction
{
public:
  ON_OffsetSurfaceFunction();
  ~ON_OffsetSurfaceFunction();

  /*
  Description:
    Sets base surface for the offset function.
  Parameters:
    srf - [in] pointer to the base surface.
               This surface must remain valid while
               the ON_OffsetSurfaceFunction class is used.
  Returns:
    True if successful.
  */
  bool SetBaseSurface(
    const ON_Surface* srf 
    );

  /*
  Returns:
    Base surface specified SetBaseSurface().
  */
  const ON_Surface* BaseSurface() const;

  /*
  Description:
    Use set SetSideTangency if you want the offset 
    surface and base surface to have the same unit
    normals along a side of the surfaces's parameter
    spaces.
  Parameters:
    side - [in]
               0 = south side
               1 = east side
               2 = north side
               3 = west side
    bEnable - [in] true to enable tangency,
                   false to disable tangency
  Returns:
    True if successful.
  */
  bool SetSideTangency(
    int side,
    bool bEnable
    );

  /*
  Parameters:
    side - [in]
               0 = south side
               1 = east side
               2 = north side
               3 = west side
  Returns:
    True if side tangency is enabled.
  */
  bool SideTangency(int side) const;

  /*
  Description:
    Sets the offset distance at a point.  Call this function
    once for each point wher the user specifies an offset.
  Parameters:
    s - [in]
    t - [in] (s,t) is a base surface evaluation parameter
    distance - [in] distance is the offset distance.
    radius - [in] if radius>0, then this value will be the
                  the approximate radius of the offset "bump".
  */
  bool SetOffsetPoint(
    double s,
    double t,
    double distance,
    double radius = 0.0
    );

  /*
  Description:
    Sets the surface parameters of an existing offset point.
  Parameters:
    index - [in] index of the point to set
    s - [in]
    t - [in] (s,t) is a base surface evaluation parameter
  */
  bool SetPoint( 
    int index, 
    double s, 
    double t
    );


  /*
  Description: 
    Set the offset distance for an existing point
  Parameters:
    index - [in] index of the point to set
    distance - [in] new distance
  */
  bool SetDistance( 
    int index, 
    double distance);


  /*
  Returns:
    Number of points specified using SetOffsetPoint().
  */
  int OffsetPointCount() const;

  /*
  Parameters:
    i - [in] an index >= 0 and < OffsetPointCount()
  Returns:
    Surface parameter specified using SetOffsetPoint().
  */
  ON_2dPoint OffsetSurfaceParameter(int i) const;

  /*
  Parameters:
    i - [in] an index >= 0 and < OffsetPointCount()
  Returns:
    Offset distance specified using SetOffsetPoint().
  */
  double OffsetDistance(int i) const;

  /*
  Description:
    Value of the offset distance at any surface parameter.
  Parameters:
    s - [in]
    t - [in] (s,t) is a base surface evaluation parameter
  Returns:
    offset distance at the surface parameter
  */
  double DistanceAt(
    double s,
    double t
    ) const;

  /*
  Description:
    Value of the offset distance at any surface parameter.
  Parameters:
    s - [in]
    t - [in] (s,t) is a base surface evaluation parameter
    num_der - [in] number of derivatives
    value - [out] value and derivatives of distance function
                  value[0] = distance, value[1] = 1rst derivative,
                  value[2] = 2nd derivative, ...
  Returns:
    True if successful
  */
  bool EvaluateDistance(
        double s,
        double t,
        int num_der,
        double* value
        ) const;

  /*
  Description:
    Value of the offset function at any surface parameter.
  Parameters:
    s - [in]
    t - [in] (s,t) is a base surface evaluation parameter
  Returns:
    Point on the offset surface.
  */
  ON_3dPoint PointAt(
    double s,
    double t
    ) const;

  /*
  Description:
    Resets this class if you want to reuse it.
  */
  void Destroy();

private:
  friend class ON_OffsetSurface;
  bool Initialize();

  const ON_Surface* m_srf;

  ON_Interval m_domain[2];

  bool m_bZeroSideDerivative[4];   // S,E,N,W side

  ON_SimpleArray<ON_OffsetSurfaceValue> m_offset_value;


  ON_SimpleArray<class ON_BumpFunction> m_bumps;

  bool m_bValid;
};

class ON_CLASS ON_OffsetSurface : public ON_SurfaceProxy
{
  // This is still a work in progress.  In particular,
  // this surface class can not be saved in files, used
  // as a brep surface, added to Rhino, etc.
  //
  // As of January 2004, it is useful for calculating
  // offset meshes and any other fitting and approximation
  // tools that requires a surface evaluator but do not need
  // NURBS forms, isocurves, and so on.
  ON_OBJECT_DECLARE(ON_OffsetSurface);
public:
  ON_OffsetSurface();
  ~ON_OffsetSurface();
  ON_OffsetSurface( const ON_OffsetSurface& src);
  ON_OffsetSurface& operator=(const ON_OffsetSurface& src);

  // virtual ON_Geometry GetBBox override       
  bool GetBBox( double* boxmin, double* boxmax, bool bGrowBox = false ) const override;

  bool Evaluate( // returns false if unable to evaluate
         double, double, // evaluation parameters
         int,            // number of derivatives (>=0)
         int,            // array stride (>=Dimension())
         double*,        // array of length stride*(ndir+1)*(ndir+2)/2
         int = 0,        // optional - determines which quadrant to evaluate from
                         //         0 = default
                         //         1 from NE quadrant
                         //         2 from NW quadrant
                         //         3 from SW quadrant
                         //         4 from SE quadrant
         int* = 0        // optional - evaluation hint (int[2]) used to speed
                         //            repeated evaluations
         ) const override;

  /*
  Description:
    Sets base surface to a surface that is not managed
    by the ON_OffsetSurface class.
  Parameters:
    base_surface - [in] points to a base surface the
       caller insures will exist for the lifetimes
       of the ON_OffsetSurface class.
  Returns:
    True if successful.
  */
  bool SetBaseSurface(
    const ON_Surface* base_surface
    );

  /*
  Description:
    Sets base surface to a surface that is optionally managed
    by the ON_OffsetSurface class.
  Parameters:
    base_surface - [in] points to a base surface the
       caller insures will exist for the lifetimes
       of the ON_OffsetSurface class.
    bManage - [in] if true, the base_surface must point
       to a surface that is on the heap and the surface
       will be deleted by ~ON_OffsetSurface.
  Returns:
    True if successful.
  */
  bool SetBaseSurface(
        ON_Surface* base_surface, 
        bool bManage
        );

  /*
  Returns:
    Base surface;
  */
  const ON_Surface* BaseSurface() const;

  ON_OffsetSurfaceFunction& OffsetFunction();
  const ON_OffsetSurfaceFunction& OffsetFunction() const;

private:
  // If not nullptr, this points to the base surface
  ON_Surface* m__pSrf;
  ON_OffsetSurfaceFunction m_offset_function;
};


#endif