BsplineStructs.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once
#include <Bentley/RefCounted.h>
#ifndef MS_BSPLINE_STRUCTURES_DEFINED
#define MS_BSPLINE_STRUCTURES_DEFINED

BEGIN_BENTLEY_GEOMETRY_NAMESPACE

/* B-Spline curve types */
#define     BSCURVE_GENERAL             0
#define     BSCURVE_LINE                1
#define     BSCURVE_CIRCULAR_ARC        2
#define     BSCURVE_CIRCLE              3
#define     BSCURVE_ELLIPTICAL_ARC      4
#define     BSCURVE_ELLIPSE             5
#define     BSCURVE_PARABOLIC_ARC       6
#define     BSCURVE_HYPERBOLIC_ARC      7

/* B-Spline surface types */
#define     BSSURF_GENERAL              0
#define     BSSURF_PLANE                1
#define     BSSURF_RIGHT_CYLINDER       2
#define     BSSURF_CONE                 3
#define     BSSURF_SPHERE               4
#define     BSSURF_TORUS                5
#define     BSSURF_REVOLUTION           6
#define     BSSURF_TAB_CYLINDER         7
#define     BSSURF_RULED_SURFACE        8

/* Constants */
#define BSSURF_U 0
#define BSSURF_V 1

/* Miscellaneous Maxima */
#define MAX_POLES       MAX_VERTICES
#define MAX_ORDER       26
#define MAX_KNOTS       (MAX_POLES + 2*MAX_ORDER - 1)
#define MAX_BNDRY_PTS   MAX_VERTICES
#define MAX_DATA_PTS    MAX_VERTICES
#define MAX_BSORDER     MAX_ORDER
/* Tolerances */
#define KNOT_TOLERANCE_BASIS    1E-10

/* Fit modes */
#define FIT_POLES           0
#define FIT_POINTS          1
#define FIT_LEASTSQUARES    2
#define FIT_CATMULLROM      3

/* Offset cusp treatments */
#define OFFSET_JUMP_CUSP        0
#define OFFSET_CHAMFER_CUSP     1
#define OFFSET_POINT_CUSP       2
#define OFFSET_PARABOLA_CUSP    3
#define OFFSET_ARC_CUSP         4

/* Continuity degree specifications */
#define     POSITION_CONTINUITY     0
#define     TANGENT_CONTINUITY      1
#define     CURVATURE_CONTINUITY    2
#define     DERIVATIVE_CONTINUITY   3

/* Truncation specifications */
#define     TRUNCATE_BOTH           0
#define     TRUNCATE_NONE           1
#define     TRUNCATE_SINGLE         2

/* Iso display for silhouette curves */
#define     SILHBND_U               0
#define     SILHBND_V               1
#define     SILHBND_NONE            2
#define     SILHBND_BOTH            3

/* Surface edge classification */
#define     NO_EDGE     0x0000
#define     U0_EDGE     0x0001
#define     U1_EDGE     0x0002
#define     V0_EDGE     0x0004
#define     V1_EDGE     0x0008
#define     ANY_EDGE    0x000F

typedef int MSBsplineStatus;
#define MSB_SUCCESS 0
#define MSB_ERROR   0x8000


struct GEOMDLLIMPEXP bSplineParam
    {
    int32_t             order;
    int32_t             closed;
    int32_t             numPoles;
    int32_t             numKnots;               /* # interior knots or zero for uniform */
    int32_t             numRules;

    int NumberAllocatedKnots () const;
    static int NumberAllocatedKnots (int32_t numPoles, int32_t order, int32_t closed);

    static int NumberInteriorKnots (int32_t numPoles, int32_t order, int32_t closed);

    };


struct interpolationParam
    {
    int32_t             order;                  /* default 4 */
    int32_t             isPeriodic;
    int32_t             numPoints;              /* including duplicate pt if periodic */
    int32_t             numKnots;               /* # full knots, never zero */
    int32_t             isChordLenKnots;        /* default 1 */
    int32_t             isColinearTangents;     /* default 0 */
    int32_t             isChordLenTangents;     /* default 1 */
    int32_t             isNaturalTangents;      /* default 1 */
    };


struct bsplineDisplay
    {
    int32_t             polygonDisplay;
    int32_t             curveDisplay;
    int32_t             rulesByLength;
    };



struct BCurveSegment
    {
    private:
    // Centroid, length integrals with optional centroid.
    void WireIntegrals (double &length, DPoint3dP centroid, 
            double fractionA, double fractionB);
    public:
    enum
        {
        MaxOrder = 26,
        };
    private:
    DPoint4d m_poles[MaxOrder];
    DPoint4d m_workPoles[MaxOrder];
    double   m_knots[2 * MaxOrder];
    size_t   m_order;
    size_t   m_workOrder;
    size_t   m_numKnots;

    //friend struct MSBsplineCurve;
    friend bool bspcurv_getSupport (MSBsplineCurveCR curve, BCurveSegmentR segment, size_t bezierSelect);
    friend GEOMDLLIMPEXP  int bspproc_prepareCurve (MSBsplineCurveP, int*, int **, MSBsplineCurveP);

    size_t m_index;
    double m_uMin;
    double m_uMax;
    bool  m_isNullU;
    public:

    GEOMDLLIMPEXP BCurveSegment ();

    GEOMDLLIMPEXP void FractionToPoint (DPoint3dR xyz, double f) const;

    GEOMDLLIMPEXP DPoint3d FractionToPoint (double f) const;

    GEOMDLLIMPEXP double FractionToKnot (double f) const;

    GEOMDLLIMPEXP void FractionToPoint (DPoint3dR xyz, DVec3dR tangent, double f, bool applyKnotScale = true) const;

    GEOMDLLIMPEXP void CopyFrom (BCurveSegmentCR source, DMatrix4dCP matrix = NULL);

    GEOMDLLIMPEXP void CopyFrom (BCurveSegmentCR source, RotMatrixCR matrix);

    GEOMDLLIMPEXP void CopyFrom (BCurveSegmentCR source, TransformCR matrix);
    
    GEOMDLLIMPEXP void WireCentroid (double &length, DPoint3dR centroid, double fraction0, double fraction1);

    GEOMDLLIMPEXP void Length (double &length, double fraction0, double fraction1);
    GEOMDLLIMPEXP void Length (RotMatrixCP worldToLocal, double &length, double fraction0, double fraction1);


    GEOMDLLIMPEXP double PolygonLength () const;

    GEOMDLLIMPEXP DRange1d KnotRange () const;

    GEOMDLLIMPEXP void SaturateKnots ();

    GEOMDLLIMPEXP void AddStrokes
        (
        bvector <DPoint3d> &points,
        bvector <DVec3d> *derivatives,
        bvector<double> *params,
        IFacetOptionsCR options,
        double fractionA = 0.0,
        double fractionB = 1.0,
        bool useWorkPoles = false,
        MSBsplineCurveCP curve = NULL
        ) const;

    //GEOMDLLIMPEXP void MapBezierFractions (bvector<double> *params, CurveParameterMapping select) const;


    GEOMDLLIMPEXP bool IsRational (bool useWorkPoles = false) const;
    GEOMDLLIMPEXP DPoint4dP GetWorkPoleP (size_t index);
    GEOMDLLIMPEXP size_t GetWorkOrder ();
    GEOMDLLIMPEXP void Multiply (TransformCR transform);
    
    GEOMDLLIMPEXP void BuildWorkPoles (TransformCR transform);

    GEOMDLLIMPEXP void AddExtrema (bvector<double> &params,
                    DRange3dP range = NULL,
                    bool mapToKnots = false, size_t firstDimension = 0, size_t lastDimension = 2, bool includeStartEnd = true) const;


    GEOMDLLIMPEXP bool TryGetPoleXYZ (size_t index, DPoint3dR xyz) const;
    GEOMDLLIMPEXP DPoint4dP GetPoleP (size_t index);
    GEOMDLLIMPEXP DPoint4dP GetPoleP ();
    GEOMDLLIMPEXP size_t GetOrder ();
    GEOMDLLIMPEXP size_t GetNumKnots ();

    GEOMDLLIMPEXP double *GetKnotP (size_t index);
    GEOMDLLIMPEXP double *GetKnotP ();

    GEOMDLLIMPEXP bool IsNullU () const;
    GEOMDLLIMPEXP double UMin () const;
    GEOMDLLIMPEXP double UMax () const;

    GEOMDLLIMPEXP void SetUMin (double u);
    GEOMDLLIMPEXP void SetUMax (double u);

    GEOMDLLIMPEXP bool SubdivideToIntersection (DRange1dCR interval);

    GEOMDLLIMPEXP size_t Index () const;

    static GEOMDLLIMPEXP bool RefineCloseApproach
        (
        BCurveSegmentR curveA,
        double fractionAin,
        BCurveSegmentR curveB,
        double fractionBin,
        bool useWorkPoles,
        bool xyOnly,
        double &fractionAOut,
        DPoint3dR xyzAOut,
        double &fractionBOut,
        DPoint3dR xyzBOut
        );
    };

END_BENTLEY_GEOMETRY_NAMESPACE
#endif