AcGe.h

Go to the documentation of this file.

#pragma once
 
//
// (C) Copyright 2005-2024 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
class AcGeLibVersion;
 
struct AcGe
{
public:
        enum AcGeIntersectError
        {
        kXXOk,
        kXXIndexOutOfRange,
        kXXWrongDimensionAtIndex,
        kXXUnknown
        };
    enum KnotParameterization
    {
        kChord = 0,
        kSqrtChord = 1,
        kUniform = 2,
        kCustomParam = 15,
        kNotDefinedKnotParam = 16
    };
 
        enum AcGeXConfig
        {
        kNotDefined = 1 << 0,
        kUnknown = 1 << 1,
        kLeftRight = 1 << 2,
        kRightLeft = 1 << 3,
        kLeftLeft = 1 << 4,
        kRightRight = 1 << 5,
        kPointLeft = 1 << 6,
        kPointRight = 1 << 7,
        kLeftOverlap = 1 << 8,
        kOverlapLeft = 1 << 9,
        kRightOverlap = 1 << 10,
        kOverlapRight = 1 << 11,
        kOverlapStart = 1 << 12,
        kOverlapEnd = 1 << 13,
        kOverlapOverlap = 1 << 14
        };
        enum ClipCondition
        {
        kInvalid,
        kAllSegmentsInside,
        kSegmentsIntersect,
        kAllSegmentsOutsideZeroWinds,
        kAllSegmentsOutsideOddWinds,
        kAllSegmentsOutsideEvenWinds
        };
        enum ClipError
        {
        eOk,
        eInvalidClipBoundary,
        eNotInitialized
        };
        enum csiConfig
        {
        kXUnknown,
        kXOut,
        kXIn,
        kXTanOut,
        kXTanIn,
        kXCoincident,
        kXCoincidentUnbounded
        };
        enum EntityId
        {
                kEntity2d,
                kEntity3d,
                kPointEnt2d,
                kPointEnt3d,
                kPosition2d,
                kPosition3d,
                kPointOnCurve2d,
                kPointOnCurve3d,
                kPointOnSurface,
                kBoundedPlane,
                kCircArc2d,
                kCircArc3d,
                kConic2d,
                kConic3d,
                kCurve2d,
                kCurve3d,
                kEllipArc2d,
                kEllipArc3d,
                kLine2d,
                kLine3d,
                kLinearEnt2d,
                kLinearEnt3d,
                kLineSeg2d,
                kLineSeg3d,
                kPlanarEnt,
                kPlane,
                kRay2d,
                kRay3d,
                kSurface,
                kSphere,
                kCylinder,
                kTorus,
                kCone,
                kSplineEnt2d,
                kPolyline2d,
                kAugPolyline2d,
                kNurbCurve2d,
                kDSpline2d,
                kCubicSplineCurve2d,
                kSplineEnt3d,
                kPolyline3d,
                kAugPolyline3d,
                kNurbCurve3d,
                kDSpline3d,
                kCubicSplineCurve3d,
                kTrimmedCrv2d,
                kCompositeCrv2d,
                kCompositeCrv3d,
                kExternalSurface,
                kNurbSurface,
                kTrimmedSurface,
                kOffsetSurface,
                kEnvelope2d,
                kCurveBoundedSurface,
                kExternalCurve3d,
                kExternalCurve2d,
                kSurfaceCurve2dTo3d,
                kSurfaceCurve3dTo2d,
                kExternalBoundedSurface,
                kCurveCurveInt2d,
                kCurveCurveInt3d,
                kBoundBlock2d,
                kBoundBlock3d,
                kOffsetCurve2d,
                kOffsetCurve3d,
                kPolynomCurve3d,
                kBezierCurve3d,
                kObject,
                kFitData3d,
                kHatch,
                kTrimmedCurve2d,
                kTrimmedCurve3d,
                kCurveSampleData,
                kEllipCone,
                kEllipCylinder,
                kIntervalBoundBlock,
                kClipBoundary2d,
                kExternalObject,
                kCurveSurfaceInt,
                kSurfaceSurfaceInt,
        kHelix
        };
        enum ErrorCondition
        {
                kOk,
                k0This,
                k0Arg1,
                k0Arg2,
                kPerpendicularArg1Arg2,
                kEqualArg1Arg2,
                kEqualArg1Arg3,
                kEqualArg2Arg3,
                kLinearlyDependentArg1Arg2Arg3,
                kArg1TooBig,
                kArg1OnThis,
                kArg1InsideThis
        };
        enum ExternalEntityKind
        {
                kAcisEntity = 0,
                kExternalEntityUndefined
        };
        enum OffsetCrvExtType
        {
        kFillet,
        kChamfer,
        kExtend
        };
        enum PointContainment
        {
        kInside,
        kOutside,
        kOnBoundary,
        };
        enum ssiConfig
        {
        kSSIUnknown,
        kSSIOut,
        kSSIIn,
        kSSICoincident
        };
        enum ssiType
        {
        kSSITransverse,
        kSSITangent,
        kSSIAntiTangent
        };
public:
         ARX_API_STATIC static  AcGeLibVersion const gLibVersion;
 
public:
          AcGe &  operator=( AcGe const &);
};
 
typedef AcGe::ErrorCondition  AcGeError;
typedef AcGe::AcGeIntersectError AcGeIntersectError;