GeomApi.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/Bentley.h>
#define BEGIN_BENTLEY_GEOMETRY_INTERNAL_NAMESPACE        namespace Bentley { namespace Geom {
#define END_BENTLEY_GEOMETRY_INTERNAL_NAMESPACE          }}
#define BENTLEY_GEOMETRY_INTERNAL_NAMESPACE_NAME         Bentley::Geom
#define USING_NAMESPACE_BENTLEY_GEOMETRY_INTERNAL        using namespace BENTLEY_GEOMETRY_INTERNAL_NAMESPACE_NAME;
#define GEOMAPI_PRINTF BeConsole::Printf
#define BENTLEYGEOMETRY_MakeGeoPoint2dPublic
// make initial appearance of virtual signature unambiguous
#define GEOMAPI_VIRTUAL virtual

#ifdef jmdlgeom_internal
#include <Bentley/BeConsole.h>
#endif

#include <float.h>
#include <math.h>
#include <string.h>
#include <Bentley/bvector.h>
#include <Bentley/WString.h>
#include <algorithm>
#include "msgeomstructs_typedefs.h"
#include "GeomApi.r.h"
#include <Bentley/RefCounted.h>
#include <Bentley/NonCopyableClass.h>
#include <Bentley/ScopedArray.h>
#include <Geom/IntegerTypes/Point.h>
#include <Geom/IntegerTypes/BSIRect.h>
#include <Geom/counters.h>
BEGIN_BENTLEY_GEOMETRY_NAMESPACE







/*----------------------------------------------------------------------+
|                                                                       |
|   Constants                                                           |
|                                                                       |
+----------------------------------------------------------------------*/
#ifndef msGeomConst_pi
#define msGeomConst_piOver4     7.85398163397448280000e-001
#define msGeomConst_piOver2     1.57079632679489660000e+000
#define msGeomConst_pi          3.14159265358979310000e+000
#define msGeomConst_2pi         6.28318530717958620000e+000
#define msGeomConst_degreesPerRadian    (45.0 / msGeomConst_piOver4)
#define msGeomConst_radiansPerDegree    (msGeomConst_piOver4 / 45.0)
#endif

#ifndef PI
#define PI      3.1415926535897932384626433
#endif

/* Constants from DGN / MGDS code */
#define mgds_fc_iang_to_rad   (msGeomConst_degreesPerRadian/360000.0)
#define mgds_fc_rad_to_iang   (msGeomConst_radiansPerDegree*360000.0)
#define mgds_fc_miang_to_rad  (-1.0*msGeomConst_degreesPerRadian/360000.0)
#define mgds_fc_nearZero       1.0e-14     /* verging on zero - from mgds days*/
#define mgds_fc_condition      1.0e-12     /* matrix condition number - from mgds days */
#define mgds_fc_epsilon        0.00001     /* A reasonable epsilon for DGN / MGDS */

#define DISCONNECT  (1.7976931348623157e308)

struct Rounding
{
private:
    Rounding ();
public:
    enum RoundingMode
        {
        RoundingMode_Round = 0,
        RoundingMode_Up    = 1,
        RoundingMode_Down  = 2
        };
  static GEOMDLLIMPEXP double Round (double value, RoundingMode mode, double lowerValue, double upperValue);
};

END_BENTLEY_GEOMETRY_NAMESPACE

BEGIN_BENTLEY_GEOMETRY_NAMESPACE
struct TaggedPolygon;
typedef bvector <TaggedPolygon> TaggedPolygonVector;
typedef TaggedPolygonVector &TaggedPolygonVectorR;
typedef TaggedPolygonVector const &TaggedPolygonVectorCR;
typedef TaggedPolygonVector *TaggedPolygonVectorP;
typedef TaggedPolygonVector const *TaggedPolygonVectorCP;

typedef RefCountedPtr<struct ISolidPrimitive> ISolidPrimitivePtr;
typedef RefCountedPtr<struct ICurvePrimitive> ICurvePrimitivePtr;
typedef RefCountedPtr<struct CurveVector> CurveVectorPtr;
typedef RefCountedPtr<struct CurveVectorWithDistanceIndex> CurveVectorWithDistanceIndexPtr;

struct RefCountedMSBsplineCurve;
typedef RefCountedPtr <RefCountedMSBsplineCurve> MSBsplineCurvePtr;

struct RefCountedMSBsplineSurface;
typedef RefCountedPtr <RefCountedMSBsplineSurface> MSBsplineSurfacePtr;

typedef RefCountedPtr<struct PolyfaceHeader> PolyfaceHeaderPtr;
typedef RefCountedPtr<struct PolyfaceCoordinateAverageContext> PolyfaceCoordinateAverageContextPtr;

typedef RefCountedPtr<IGeometry> IGeometryPtr;

#ifdef CompileZeroInit
// REMARK --- zero init has problems on older compilers
//=======================================================================================
//=======================================================================================
template<typename T> struct ZeroInit
{
    ZeroInit()                           { std::memset(this, 0, sizeof(T)); }
    ZeroInit(ZeroInit const&)            { std::memset(this, 0, sizeof(T)); }
    ZeroInit(ZeroInit&&)                 { std::memset(this, 0, sizeof(T)); }
    ZeroInit& operator=(ZeroInit const&) = default;
    ZeroInit& operator=(ZeroInit&&)      = default;
};
#endif
//=======================================================================================
//=======================================================================================
template  <typename T>
struct ValueSizeSize
{
protected:
T m_value;
size_t m_tagA;
size_t m_tagB;

public:

ValueSizeSize (){}
ValueSizeSize (T const & value, size_t tagA, size_t tagB) :
    m_value (value),
    m_tagA  (tagA),
    m_tagB  (tagB)
    {
    }
size_t GetTagA () const {return m_tagA;}
size_t GetTagB () const {return m_tagB;}

size_t GetTag (bool tagA) const {return tagA ? m_tagA : m_tagB;}
void SetTagA (ptrdiff_t tag) {m_tagA = tag;}
void SetTagB (ptrdiff_t tag) {m_tagB = tag;}



T Get () const { return m_value;}
T const & GetCR () const { return m_value;}
void Set (T const &value) { m_value = value;}

// Sort callback for std::sort
static bool cbCompareTagATagB_LT (const ValueSizeSize<T> &dataA, const ValueSizeSize<T> &dataB)
    {
    if (dataA.m_tagA < dataB.m_tagA)
        return true;
    if (dataA.m_tagA > dataB.m_tagA)
        return false;
    if (dataA.m_tagB < dataB.m_tagB)
        return true;
    if (dataA.m_tagB > dataB.m_tagB)
        return false;
    // All equal ...
    return false;
    }

// Sort callback for std::sort
static bool cbCompareTagBTagA_LT (const ValueSizeSize<T> &dataA, const ValueSizeSize<T> &dataB)
    {
    if (dataA.m_tagB < dataB.m_tagB)
        return true;
    if (dataA.m_tagB > dataB.m_tagB)
        return false;
    if (dataA.m_tagA < dataB.m_tagA)
        return true;
    if (dataA.m_tagA > dataB.m_tagA)
        return false;
    // All equal ...
    return false;
    }

static void SortTagATagB (bvector <ValueSizeSize <T> > &data)
    {
    std::sort (data.begin (), data.end (), cbCompareTagATagB_LT);
    }

static void SortTagBTagA (bvector <ValueSizeSize <T> > &data)
    {
    std::sort (data.begin (), data.end (), cbCompareTagBTagA_LT);
    }

static void SortByTags (bvector <ValueSizeSize <T> > &data, bool sortAFirst)
    {
    if (sortAFirst)
        SortTagATagB (data);
    else
        SortTagBTagA (data);
    }

void SwapTags ()
    {
    std::swap (m_tagA, m_tagB);
    }
};

//=======================================================================================
//=======================================================================================
template <typename T>
struct OrderedValueSizeSize : public ValueSizeSize <T>
{
OrderedValueSizeSize (T const & value, ptrdiff_t tagA, ptrdiff_t tagB)
    : ValueSizeSize <T> (value, tagA, tagB)
    {}

// Sort callback for std::sort
static bool cbCompareValueTagATagB_LT (const OrderedValueSizeSize<T> &dataA, const OrderedValueSizeSize<T> &dataB)
    {
    if (dataA.m_value < dataB.m_value)
        return true;
    if (dataA.m_value > dataB.m_value)
        return false;
    if (dataA.m_tagA < dataB.m_tagA)
        return true;
    if (dataA.m_tagA > dataB.m_tagA)
        return false;
    if (dataA.m_tagB < dataB.m_tagB)
        return true;
    if (dataA.m_tagB > dataB.m_tagB)
        return false;
    // All equal ...
    return false;
    }

// Sort callback for std::sort
static bool cbCompareTagAValueTagB_LT (const OrderedValueSizeSize<T> &dataA, const OrderedValueSizeSize<T> &dataB)
    {
    if (dataA.m_tagA < dataB.m_tagA)
        return true;
    if (dataA.m_tagA > dataB.m_tagA)
        return false;
    if (dataA.m_value < dataB.m_value)
        return true;
    if (dataA.m_value > dataB.m_value)
        return false;
    if (dataA.m_tagB < dataB.m_tagB)
        return true;
    if (dataA.m_tagB > dataB.m_tagB)
        return false;
    // All equal ...
    return false;
    }

// Sort callback for std::sort
static bool cbCompareValue_LT (const OrderedValueSizeSize<T> &dataA, const OrderedValueSizeSize<T> &dataB)
    {
    return dataA.m_value < dataB.m_value;
    }

// Sort callback for std::sort
static bool cbCompareValue_GT (const OrderedValueSizeSize<T> &dataA, const OrderedValueSizeSize<T> &dataB)
    {
    return dataA.m_value > dataB.m_value;
    }

static void SortValueTagATagB (bvector <OrderedValueSizeSize <T> > &data)
    {
    std::sort (data.begin (), data.end (), cbCompareValueTagATagB_LT);
    }

static void SortTagAValueTagB (bvector <OrderedValueSizeSize <T> > &data)
    {
    std::sort (data.begin (), data.end (), cbCompareTagAValueTagB_LT);
    }
};
typedef OrderedValueSizeSize <double> DoubleSizeSize;
typedef ValueSizeSize <DRange3d> DRange3dSizeSize;
typedef ValueSizeSize <DPoint3d> DPoint3dSizeSize;

template<typename T>
struct ValidatedValue
    {
    private:
        T m_value;
        bool m_isValid;
    public:
        ValidatedValue() : m_value(), m_isValid(false){}
        ValidatedValue(T const &value) : m_value(value), m_isValid(true){}
        ValidatedValue(T const &value, bool isValid) : m_value(value), m_isValid(isValid){}
        T const &Value() const { return m_value; }
        T &Value() { return m_value; }
        bool IsValid() const { return m_isValid; }
        bool IsValid(T &value) const { value = m_value; return m_isValid; }
        void SetIsValid (bool value){m_isValid = value;}
        operator T (){ return m_value; }
    };

typedef ValidatedValue <struct DVec3d> ValidatedDVec3d;
typedef ValidatedValue <struct DVec2d> ValidatedDVec2d;
typedef ValidatedValue <struct RotMatrix> ValidatedRotMatrix;
typedef ValidatedValue <struct Transform> ValidatedTransform;
typedef ValidatedValue <struct DPoint2d> ValidatedDPoint2d;
typedef ValidatedValue <struct DPoint3d> ValidatedDPoint3d;
typedef ValidatedValue <struct DPoint4d> ValidatedDPoint4d;

typedef ValidatedValue <struct DPlane3d> ValidatedDPlane3d;
typedef ValidatedValue <double> ValidatedDouble;

typedef ValidatedValue <DSegment1d> ValidatedDSegment1d;
typedef ValidatedValue <DSegment3d> ValidatedDSegment3d;
typedef ValidatedValue <CurveLocationDetail> ValidatedCurveLocationDetail;

typedef ValidatedValue <DEllipse3d> ValidatedDEllipse3d;
typedef ValidatedValue <DRay3d> ValidatedDRay3d;
typedef ValidatedValue <DrapeSegment> ValidatedDrapeSegment;
typedef ValidatedValue <size_t> ValidatedSize;
typedef ValidatedValue <DPlane3dByVectors> ValidatedDPlane3dByVectors;
typedef ValidatedValue <LocalRange> ValidatedLocalRange;
typedef ValidatedValue <struct DRange3d> ValidatedDRange3d;
typedef ValidatedValue <LocalRange> ValidatedLocalRange;

template<typename T>
void CompressDuplicates (bvector<T> &data, bool (*SameMember)(T const &memberA, T const &memberB))
    {
    size_t numTotal = data.size ();
    if (numTotal > 1)
        {
        size_t numAccept = 0;
        for (size_t candidate = 1; candidate < numTotal; candidate++)
            {
            if (!SameMember (data[numAccept], data[candidate]))
                {
                numAccept++;
                if (candidate > numAccept)
                    data[numAccept] = data[candidate];
                }
            }
        data.resize (numAccept);
        }
    }



//=======================================================================================
//=======================================================================================
struct IGeometry : RefCountedBase
{
public:

enum class GeometryType
    {
    CurvePrimitive      = 1,
    CurveVector         = 2,
    SolidPrimitive      = 3,
    BsplineSurface      = 4,
    Polyface            = 5,
    };

friend struct OrderedIGeometryPtr;
private:
    virtual void MakeClassAbstract() = 0;
public:
public:

GEOMDLLIMPEXP GeometryType GetGeometryType () const;

GEOMDLLIMPEXP ICurvePrimitivePtr GetAsICurvePrimitive () const;
GEOMDLLIMPEXP CurveVectorPtr GetAsCurveVector () const;
GEOMDLLIMPEXP ISolidPrimitivePtr GetAsISolidPrimitive () const;
GEOMDLLIMPEXP MSBsplineSurfacePtr GetAsMSBsplineSurface () const;
GEOMDLLIMPEXP PolyfaceHeaderPtr GetAsPolyfaceHeader () const;

GEOMDLLIMPEXP bool TryGetRange (DRange3dR range) const;
GEOMDLLIMPEXP bool TryTransformInPlace (TransformCR transform);
GEOMDLLIMPEXP bool IsSameStructureAndGeometry (IGeometryCR other, double tolerance = 0.0) const;
GEOMDLLIMPEXP static IGeometryPtr Create (ICurvePrimitivePtr const& source);
GEOMDLLIMPEXP static IGeometryPtr Create (CurveVectorPtr const& source);
GEOMDLLIMPEXP static IGeometryPtr Create (ISolidPrimitivePtr const& source);
GEOMDLLIMPEXP static IGeometryPtr Create (MSBsplineSurfacePtr const& source);
GEOMDLLIMPEXP static IGeometryPtr Create (PolyfaceHeaderPtr const& source);

}; // IGeometry


struct OrderedIGeometryPtr
{
IGeometryPtr m_geometry;
OrderedIGeometryPtr (IGeometryPtr const &target){m_geometry = target;}
OrderedIGeometryPtr (){}
OrderedIGeometryPtr (ICurvePrimitiveCR target)
    {
    ICurvePrimitivePtr myPtr (const_cast <ICurvePrimitiveP>(&target));
    m_geometry = IGeometry::Create (myPtr);
    }

OrderedIGeometryPtr (CurveVectorCR target)
    {
    CurveVectorPtr myPtr (const_cast <CurveVectorP>(&target));
    m_geometry = IGeometry::Create (myPtr);
    }

OrderedIGeometryPtr (PolyfaceHeaderCR target)
    {
    PolyfaceHeaderPtr myPtr (const_cast <PolyfaceHeaderP>(&target));
    m_geometry = IGeometry::Create (myPtr);
    }

OrderedIGeometryPtr (ISolidPrimitiveCR target)
    {
    ISolidPrimitivePtr myPtr (const_cast <ISolidPrimitiveP>(&target));
    m_geometry = IGeometry::Create (myPtr);
    }

OrderedIGeometryPtr (ICurvePrimitivePtr const &target) {m_geometry = IGeometry::Create (target);}
OrderedIGeometryPtr (CurveVectorPtr const &target) {m_geometry = IGeometry::Create (target);}
OrderedIGeometryPtr (ISolidPrimitivePtr const &target) {m_geometry = IGeometry::Create (target);}
OrderedIGeometryPtr (PolyfaceHeaderPtr const &target) {m_geometry = IGeometry::Create (target);}
OrderedIGeometryPtr (MSBsplineSurfacePtr const &target) {m_geometry = IGeometry::Create (target);}

GEOMDLLIMPEXP bool operator < (OrderedIGeometryPtr const &other) const;
};



END_BENTLEY_GEOMETRY_NAMESPACE

#include "dpoint2d.h"
#include "dpoint3d.h"
#include "dpoint4d.h"
#include "GraphicsPoint.h"
#include "GeoPoint.h"
#include "dvec2d.h"
#include "dvec3d.h"
#include "DRange1d.h"
#include "drange2d.h"
#include "drange3d.h"
#include "dmatrix4d.h"
#include "dmap4d.h"
#include "dplane3d.h"
#include "dray3d.h"
#include "DSegment1d.h"
#include "dsegment3d.h"
#include "dellipse3d.h"
#include "rotmatrix.h"
#include "transform.h"
#include "BsplineStructs.h"
#include <Geom/CurveDetails.h>
#include "OperatorOverload.h"

#include "MSBsplineCurve.h"
#include "MSInterpolationCurve.h"
#include "MSBsplineSurface.h"
#include "Angle.h"

#include "DPoint3dOps.h"

BEGIN_BENTLEY_GEOMETRY_NAMESPACE
//=======================================================================================
//=======================================================================================
struct MeshAnnotation
    {
    Utf8String m_description;   //<! name of error condtion tested
    size_t  m_pass;             //<! number of times passed
    size_t m_fail;              //<! number of times failed
    bvector<std::pair<size_t, ptrdiff_t>> m_indices;    
    bvector<std::pair<size_t, DPoint3d>> m_xyz;         

    MeshAnnotation (Utf8CP name) : m_description (name), m_pass (0), m_fail (0) {}

    void IncrementPass () {m_pass++;}
    void IncrementFail () {m_fail++;}
    void Record (size_t index, size_t tag) { m_indices.push_back (std::pair<size_t, ptrdiff_t> (index, (ptrdiff_t)tag)); }
    void Record (size_t index, DPoint3dCR tag) { m_xyz.push_back (std::pair<size_t, DPoint3d> (index, tag)); }
    void Record (size_t index, int tag) { m_indices.push_back (std::pair<size_t, ptrdiff_t> (index, (ptrdiff_t)tag)); }
    };
//=======================================================================================
//=======================================================================================
struct MeshAnnotationVector : bvector<MeshAnnotation>
{
private:
bool m_recordAllTestDescriptions;
size_t m_totalPass;
size_t m_totalFail;
public:
    MeshAnnotationVector (bool recordAllTestDescriptions) : m_recordAllTestDescriptions (recordAllTestDescriptions), m_totalPass (0), m_totalFail (0)
    { }
size_t GetTotalPass () { return m_totalPass;}
size_t GetTotalFail () { return m_totalFail;}
    size_t Find (Utf8CP key);
    size_t FindOrAdd (Utf8CP key);
    size_t Assert (bool condition, Utf8CP key);
    void Assert (bool condition, Utf8CP key, size_t index, size_t tag);
    void Assert (bool condition, Utf8CP key, size_t index, DPoint3dCR tag);
    void Assert (bool condition, Utf8CP key, size_t index, int tag);
};
END_BENTLEY_GEOMETRY_NAMESPACE

#include <Geom/ClipPlane.h>
#include <Geom/ClipPlaneSet.h>
#include <Geom/CompoundDrawState.h>
#include <Geom/CurvePrimitiveId.h>
#include <Geom/CurvePrimitive.h>
#include <Geom/CurveVector.h>
#include <Geom/SolidPrimitive.h>
#include <Geom/CurveTopologyId.h>
#include <Geom/Polyface.h>


BEGIN_BENTLEY_GEOMETRY_NAMESPACE

typedef struct pointList
    {
    int32_t             numPoints;
    DPoint3d            *points;
    } PointList;

END_BENTLEY_GEOMETRY_NAMESPACE