@itwin/core-common

import { BentleyStatus, Id64String } from "@itwin/core-bentley"; import { Angle, GeometryQuery, Point2d, Point3d, Range3d, Transform, Vector3d, YawPitchRollAngles } from "@itwin/core-geometry"; import { TextString, TextStringGlyphData, TextStringProps } from "./TextString"; import { GeometryParams } from "../GeometryParams"; import { BRepEntity } from "./GeometryStream"; import { ImageGraphic, ImageGraphicProps } from "./ImageGraphic"; import { ElementAlignedBox3d, Placement3d } from "./Placement"; import { PlacementProps } from "../ElementProps"; import { TextBlockGeometryProps } from "../annotation/TextBlockGeometryProps"; /** Specifies the type of an entry in a geometry stream. * @see [[ElementGeometryDataEntry.opcode]]. * @public * @extensions */ export declare enum ElementGeometryOpcode { /** Local range of the next geometric primitive in the geometry stream. */ SubGraphicRange = 2, /** A reference to a [GeometryPart]($backend). */ PartReference = 3, /** Sets symbology for subsequent geometry to override [SubCategory]($backend) appearance */ BasicSymbology = 4, /** A line, line string, shape, or point string (automatic simplification of a [CurvePrimitive]($core-geometry) or [CurveCollection]($core-geometry)) */ PointPrimitive = 5, /** A 2d line, line string, shape, or point string (automatic simplification of a [CurvePrimitive]($core-geometry) or [CurveCollection]($core-geometry)) */ PointPrimitive2d = 6, /** Arc or ellipse (automatic simplification of a [CurvePrimitive]($core-geometry) or [CurveCollection]($core-geometry)) */ ArcPrimitive = 7, /** [CurveCollection]($core-geometry) */ CurveCollection = 8, /** [Polyface]($core-geometry) */ Polyface = 9, /** [CurvePrimitive]($core-geometry) */ CurvePrimitive = 10, /** [SolidPrimitive]($core-geometry) */ SolidPrimitive = 11, /** [BSplineSurface3d]($core-geometry) */ BsplineSurface = 12, /** Opaque and [[Gradient]] fills. */ Fill = 19, /** Hatch, cross-hatch, or [[AreaPattern]]. */ Pattern = 20, /** [[RenderMaterial]] */ Material = 21, /** [[TextString]] */ TextString = 22, /** Specifies line style overrides as a [[LineStyle.Modifier]] */ LineStyleModifiers = 23, /** Boundary representation solid, sheet, or wire body as a [[BRepEntity.DataProps]] */ BRep = 25, /** Small single-tile raster image as an [[ImageGraphic]] */ Image = 28 } /** Describes an entry in a geometry stream as an op-code plus the binary flatbuffer representation of the associated data. * @see [[FlatBufferGeometryStream]]. * @public * @extensions */ export interface ElementGeometryDataEntry { /** The type of this entry. */ opcode: ElementGeometryOpcode; /** Zero-based flatbuffer-encoded data. */ data: Uint8Array; } /** Information provided to [[ElementGeometryFunction]]. * @beta */ export interface ElementGeometryInfo { /** ID for the [Category]($core-backend), undefined for geometry parts */ categoryId?: Id64String; /** A row-major storage 4x3 transform to world coordinate, undefined for geometry parts */ sourceToWorld?: Float64Array; /** The element aligned bounding box for the geometry stream stored as 6 values for low/high */ bbox?: Float64Array; /** If true, geometry displays oriented to face the camera */ viewIndependent?: boolean; /** If true, geometry stream contained breps that were omitted or replaced as requested */ brepsPresent?: boolean; /** The geometry stream data */ entryArray: ElementGeometryDataEntry[]; } /** A callback function that receives geometry stream data. * @see [IModelDb.elementGeometryRequest]($core-backend) * @beta */ export type ElementGeometryFunction = (info: ElementGeometryInfo) => void; /** Parameters for [IModelDb.elementGeometryRequest]($core-backend) * @beta */ export interface ElementGeometryRequest { /** The source element for the geometry stream */ elementId: Id64String; /** A function to call for the geometry stream data */ onGeometry: ElementGeometryFunction; /** Whether to omit BRep data */ skipBReps?: boolean; /** When not omitting BReps, whether to return a mesh or curve representation instead of the brep data */ replaceBReps?: boolean; /** Option for replaceBReps, max distance from a face to the original geometry, see [StrokeOptions]($core-geometry) */ chordTol?: number; /** Option for replaceBReps, max angle difference in radians for approximated face, see [StrokeOptions]($core-geometry) */ angleTol?: number; /** Option for replaceBReps, max length of any edge in generated faces, see [StrokeOptions]($core-geometry) */ maxEdgeLength?: number; /** Option for replaceBReps, ignore faces with bounding boxes smaller than this size when facetting */ minBRepFeatureSize?: number; } /** Parameters for building the geometry stream of a [GeometricElement]($backend) using [[ElementGeometry.Builder]]. * You can assign an object of this type to [[GeometricElementProps.elementGeometryBuilderParams]] when inserting or updating a geometric element. * @note The geometry stream is always in local coordinates - that is, relative to the element's [[Placement]]. * @public */ export interface ElementGeometryBuilderParams { /** The geometry stream data. Calling update element with a zero length array will clear the geometry stream and invalidate the placement. */ entryArray: ElementGeometryDataEntry[]; /** If true, create geometry that always displays oriented to face the camera */ viewIndependent?: boolean; } /** Parameters for building the geometry stream of a [GeometryPart]($backend) using [[ElementGeometry.Builder]]. * You can assign an object of this type to [[GeometryPartProps.elementGeometryBuilderParams]] when inserting or updating a part. * @public */ export interface ElementGeometryBuilderParamsForPart { /** The geometry stream data */ entryArray: ElementGeometryDataEntry[]; /** If true, create geometry part with 2d geometry */ is2dPart?: boolean; } /** Request parameters for [IModelDb.updateElementGeometryCache]($core-backend) * @beta */ export interface ElementGeometryCacheRequestProps { /** Geometric element to populate geometry cache for. Clear cache for all elements when undefined. */ id?: Id64String; } /** Response parameters for [IModelDb.updateElementGeometryCache]($core-backend) * @beta */ export interface ElementGeometryCacheResponseProps { /** Cache creation status */ status: BentleyStatus; /** Count of displayable entries in element's geometry stream */ numGeom?: number; /** Count of part references in element's geometry stream */ numPart?: number; /** Count of solid/volumetric geometry in element's geometry stream */ numSolid?: number; /** Count of surface/region geometry in element's geometry stream */ numSurface?: number; /** Count of curve/path geometry in element's geometry stream */ numCurve?: number; /** Count of text/image/non-geometric displayable entries in element's geometry stream */ numOther?: number; } /** Request parameters for [IModelDb.elementGeometryCacheOperation]($core-backend) * @beta */ export interface ElementGeometryCacheOperationRequestProps { /** Target element id, tool element ids can be supplied by parameters... */ id: Id64String; /** Requested operation */ op: number; /** Parameters for operation */ params?: any; /** Callback for result when element's geometry stream is requested in flatbuffer or graphic formats */ onGeometry?: ElementGeometryFunction; } /** Values for [[BRepGeometryCreate.operation]] * @alpha */ export declare enum BRepGeometryOperation { /** Unite target (first entry) with one or more tool entities. */ Unite = 0, /** Subtract one or more tool entities from target entity (first entry) */ Subtract = 1, /** Intersect target (first entry) with one or more tool entities */ Intersect = 2, /** Sew the given set of surfaces together by joining those that share edges in common */ Sew = 3, /** Create a cut in the target (first entry) using a planar region (second entry) and optional depth */ Cut = 4, /** Create a pad or pocket in the target (first entry) using a planar region (second entry) */ Emboss = 5, /** Create a solid from a surface by offsetting using the specified forward and backward distances */ Thicken = 6, /** Create a shelled solid by offsetting all faces by the supplied distance */ Hollow = 7, /** Create a solid or surface by sweeping a planar profile (first entry) along a path (second entry) */ Sweep = 8, /** Create a solid or surface by lofting through a set of paths or regions */ Loft = 9, /** Create a solid or sheet with all non-smooth/non-laminar edges rounded */ Round = 10, /** Offset all faces of a solid or sheet target by the supplied distance. */ Offset = 11 } /** Parameters for [[BRepGeometryOperation.Cut]] * @alpha */ export interface BRepCutProps { /** Optional cut depth; through solid if not specified */ distance?: number; /** Optional cut direction; in direction of profile normal if not specified */ bothDirections?: boolean; } /** Parameters for [[BRepGeometryOperation.Thicken]] * @alpha */ export interface BRepThickenProps { /** Offset to apply in surface normal direction; at least one of frontDistance or backDistance must be specified */ frontDistance?: number; /** Offset to apply in reverse surface normal direction */ backDistance?: number; } /** Parameters for [[BRepGeometryOperation.Hollow]] * @alpha */ export interface BRepHollowProps { /** Offset to apply to all faces; positive value shells outwards, negative value shells inwards */ distance: number; } /** Parameters for [[BRepGeometryOperation.Round]] * @alpha */ export interface BRepRoundProps { /** Radius to apply to all non-laminar/non-smooth edges */ radius: number; } /** Parameters for [[BRepGeometryOperation.Offset]] * @alpha */ export interface BRepOffsetProps { /** Offset to apply to all faces; positive value offsets outwards, negative value offsets inwards */ distance: number; } /** Parameters for [IModelDb.createBRepGeometry]($core-backend) * @alpha */ export interface BRepGeometryCreate { /** The operation to perform on the input geometry */ operation: BRepGeometryOperation; /** The input target and tool geometry (curves, surfaces, and solids) to perform the given operation on */ entryArray: ElementGeometryDataEntry[]; /** A function to call for the result geometry */ onResult: BRepGeometryFunction; /** Whether disjoint results should be returned as multiple entries or a single disjoint body */ separateDisjoint?: boolean; /** Options and parameters for this operation */ parameters?: BRepCutProps | BRepThickenProps | BRepHollowProps | BRepRoundProps | BRepOffsetProps; } /** Information provided to [[BRepGeometryFunction]]. * @alpha */ export interface BRepGeometryInfo { /** The result geometry if the operation was successful */ entryArray: ElementGeometryDataEntry[]; } /** A callback function that receives brep operation result geometry. * @see [IModelDb.createBRepGeometry]($core-backend) * @alpha */ export type BRepGeometryFunction = (info: BRepGeometryInfo) => void; /** Provides utility functions for working with [[ElementGeometryDataEntry]]. * @beta */ export declare namespace ElementGeometry { /** [[ElementGeometry.Builder]] is a helper class for populating a [[ElementGeometryDataEntry]] array needed to create a [[GeometricElement]] or [[GeometryPart]]. */ class Builder { private _localToWorld?; private _worldToLocal?; /** GeometryStream entries */ readonly entries: ElementGeometryDataEntry[]; /** Current placement transform, converts local coordinate (placement relative) input to world */ get localToWorld(): Transform | undefined; /** Current inverse placement transform, converts world coordinate input to local (placement relative) */ get worldToLocal(): Transform | undefined; /** Supply optional local to world transform. Used to transform world coordinate input relative to element placement. * For a [[GeometricElement]]'s placement to be meaningful, world coordinate geometry should never be appended to an element with an identity placement. * Can be called with undefined or identity transform to start appending geometry supplied in local coordinates again. */ setLocalToWorld(localToWorld?: Transform): void; /** Supply local to world transform from a Point3d and optional YawPitchRollAngles. * @see [[Placement3d]] */ setLocalToWorld3d(origin: Point3d, angles?: YawPitchRollAngles): void; /** Supply local to world transform from a Point2d and optional Angle. * @see [[Placement2d]] */ setLocalToWorld2d(origin: Point2d, angle?: Angle): void; /** Supply local to world transform from a PlacementProps2d or PlacementProps3d. * @see [[PlacementProps]] */ setLocalToWorldFromPlacement(props: PlacementProps): void; /** Compute angles suitable for passing to [[setLocalToWorld3d]] from an array of 3d points. */ static placementAnglesFromPoints(pts: Point3d[], defaultUp?: Vector3d, result?: YawPitchRollAngles): YawPitchRollAngles; /** Compute angle suitable for passing to [[setLocalToWorld2d]] from an array of xy plane points. */ static placementAngleFromPoints(pts: Point3d[], result?: Angle): Angle; /** Store local ranges for all subsequent geometry appended. Can improve performance of range testing for elements with a GeometryStream * containing more than one [[GeometryQuery]] differentiable by range. Not useful for a single [[GeometryQuery]] as its range and that of the [[GeometricElement]] are the same. * Ignored when defining a [[GeometryPart]] and not needed when only appending [[GeometryPart]] instances to a [[GeometricElement]] as these store their own range. */ appendGeometryRanges(): boolean; /** Change [[GeometryParams]] for subsequent geometry. * It is not valid to change the sub-category when defining a [[GeometryPart]]. A [[GeometryPart]] inherits the symbology of their instance for anything not explicitly overridden. */ appendGeometryParamsChange(geomParams: GeometryParams): boolean; /** Append a [[GeometryQuery]] supplied in either local or world coordinates to the [[ElementGeometryDataEntry]] array */ appendGeometryQuery(geometry: GeometryQuery): boolean; /** Append a [[TextString]] supplied in either local or world coordinates to the [[ElementGeometryDataEntry]] array */ appendTextString(text: TextString): boolean; /** Append a series of entries representing a [[TextBlock]] to the [[ElementGeometryDataEntry]] array. * @beta */ appendTextBlock(block: TextBlockGeometryProps, geomParams?: GeometryParams): boolean; /** Append a [[ImageGraphic]] supplied in either local or world coordinates to the [[ElementGeometryDataEntry]] array */ appendImageGraphic(image: ImageGraphic): boolean; /** Append a [[BRepEntity.DataProps]] supplied in either local or world coordinates to the [[ElementGeometryDataEntry]] array. * Provided for compatibility with GeometryStreamBuilder only. * Backend code should use IModelDb.createBRepGeometry to create a brep [[ElementGeometryDataEntry]] directly. */ appendBRepData(brep: BRepEntity.DataProps): boolean; /** Append a [[GeometryPart]] instance with relative transform to the [[ElementGeometryDataEntry]] array for creating a [[GeometricElement]]. * Not valid when defining a [[GeometryPart]] as nesting of parts is not supported. */ appendGeometryPart(partId: Id64String, partTransform?: Transform): boolean; /** Append a [[GeometryPart]] instance with relative position, orientation, and scale to the [[ElementGeometryDataEntry]] array for creating a [[GeometricElement3d]]. * Not valid when defining a [[GeometryPart]] as nesting of parts is not supported. */ appendGeometryPart3d(partId: Id64String, instanceOrigin?: Point3d, instanceRotation?: YawPitchRollAngles, instanceScale?: number): boolean; /** Append a [[GeometryPart]] instance with relative position, orientation, and scale to the [[ElementGeometryDataEntry]] array for creating a [[GeometricElement2d]]. * Not valid when defining a [[GeometryPart]] as nesting of parts is not supported. */ appendGeometryPart2d(partId: Id64String, instanceOrigin?: Point2d, instanceRotation?: Angle, instanceScale?: number): boolean; } /** Current state information for [[ElementGeometry.Iterator]] */ interface IteratorData { /** A [[GeometryParams]] representing the appearance of the current geometric entry */ readonly geomParams: GeometryParams; /** Placement transform, used for converting placement relative, local coordinate entries to world */ readonly localToWorld?: Transform; /** Optional stored local range for the current geometric entry */ readonly localRange?: Range3d; /** The current displayable opcode */ readonly value: ElementGeometryDataEntry; } class IteratorEntry implements IteratorData { readonly geomParams: GeometryParams; readonly localToWorld?: Transform; localRange?: Range3d; private _value?; private readonly _applyLocalToWorld; constructor(geomParams: GeometryParams, localToWorld: Transform, applyLocalToWorld?: boolean); get value(): ElementGeometryDataEntry; set value(value: ElementGeometryDataEntry); get outputTransform(): Transform | undefined; /** Return the [[GeometryQuery]] representation for the current entry */ toGeometryQuery(): GeometryQuery | undefined; /** Return the [[BRepEntity.DataProps]] representation for the current entry for checking brep type and face attachments. */ toBRepData(wantBRepData?: boolean): BRepEntity.DataProps | undefined; /** Return the [[TextString]] representation for the current entry */ toTextString(): TextString | undefined; /** Return the [[ImageGraphic]] representation for the current entry */ toImageGraphic(): ImageGraphic | undefined; /** Return the GeometryPart information for the current entry */ toGeometryPart(partToLocal?: Transform, partToWorld?: Transform): Id64String | undefined; } /** [[ElementGeometry.Iterator]] is a helper class for iterating a [[ElementGeometryDataEntry]] array. * Each [[ElementGeometryDataEntry]] returned by the iterator represents exactly one displayable entry. */ class Iterator implements IterableIterator<IteratorEntry> { /** GeometryStream entries */ readonly entryArray: ElementGeometryDataEntry[]; /** The geometric element's placement or geometry part's local range (placement.bbox) */ readonly placement: Placement3d; /** If true, geometry displays oriented to face the camera */ readonly viewIndependent?: boolean; /** If true, geometry stream contained breps that were omitted or replaced as requested */ readonly brepsPresent?: boolean; /** Current entry position */ private _index; /** Allocated on first call to next() and reused thereafter */ private _entry?; /** Used to initialize this._entry */ private readonly _appearance; private readonly _localToWorld; /** Whether deserialized entry data is returned in world or local coordinates */ private _applyLocalToWorld; /** Construct a new Iterator given a [[ElementGeometryInfo]] from either a [[GeometricElement3d]], [[GeometricElement2d]], or [[GeometryPart]]. * Supply the optional [[GeometryParams]] and localToWorld transform to iterate a [[GeometryPart]] in the context of a [[GeometricElement]] reference. */ constructor(info: ElementGeometryInfo, categoryOrGeometryParams?: Id64String | GeometryParams, localToWorld?: Transform); /** Call to return deserialized entry data in world coordinates */ requestWorldCoordinates(): void; private get entry(); /** Advance to next displayable opcode (geometric entry or geometry part) while updating the current [[GeometryParams]] from appearance related opcodes. */ next(): IteratorResult<IteratorEntry>; [Symbol.iterator](): IterableIterator<IteratorEntry>; } /** Return whether the supplied entry can be represented as a [[GeometryQuery]] */ function isGeometryQueryEntry(entry: ElementGeometryDataEntry): boolean; /** Return whether the supplied entry is displayable geometry [[GeometryQuery]], [[BRepEntity.DataProps]], [[TextString]], or [[ImageGraphic]] */ function isGeometricEntry(entry: ElementGeometryDataEntry): boolean; /** Return whether the supplied entry is geometric or a part reference */ function isDisplayableEntry(entry: ElementGeometryDataEntry): boolean; /** Return whether the supplied entry represents appearance information */ function isAppearanceEntry(entry: ElementGeometryDataEntry): boolean; /** Return whether the supplied entry represents a single open curve or path */ function isCurve(entry: ElementGeometryDataEntry): boolean; /** Return whether the supplied entry represents a loop, planar region, open polyface, or sheet body */ function isSurface(entry: ElementGeometryDataEntry): boolean; /** Return whether the supplied entry represents a capped solid, closed polyface, or solid body */ function isSolid(entry: ElementGeometryDataEntry): boolean; /** Return the body type that would be used to represent the supplied entry */ function getBRepEntityType(entry: ElementGeometryDataEntry): BRepEntity.Type | undefined; /** Return entry as a [[GeometryQuery]] */ function toGeometryQuery(entry: ElementGeometryDataEntry, localToWorld?: Transform): GeometryQuery | undefined; /** Create entry from a [[GeometryQuery]] */ function fromGeometryQuery(geom: GeometryQuery, worldToLocal?: Transform): ElementGeometryDataEntry | undefined; /** Return entry as a [[TextString]] */ function toTextString(entry: ElementGeometryDataEntry, localToWorld?: Transform): TextStringProps | undefined; /** Returns only the [[TextStringGlyphData]] embedded in the [[TextString]] flatbuffer. This data is only internal to the native display libaries. */ function toTextStringGlyphData(entry: ElementGeometryDataEntry): TextStringGlyphData | undefined; /** Create entry from a [[TextString]] */ function fromTextString(text: TextStringProps, worldToLocal?: Transform, glyphs?: TextStringGlyphData): ElementGeometryDataEntry | undefined; /** Return entry as a [[ImageGraphic]] */ function toImageGraphic(entry: ElementGeometryDataEntry, localToWorld?: Transform): ImageGraphicProps | undefined; /** Create entry from a [[ImageGraphic]] */ function fromImageGraphic(image: ImageGraphicProps, worldToLocal?: Transform): ElementGeometryDataEntry | undefined; /** Return entry as a [[BRepEntity.DataProps]] for checking brep type and face attachments. */ function toBRep(entry: ElementGeometryDataEntry, wantBRepData?: boolean, localToWorld?: Transform): BRepEntity.DataProps | undefined; /** Create entry from a [[BRepEntity.DataProps]]. Provided for compatibility with GeometryStreamBuilder only. */ function fromBRep(brep: BRepEntity.DataProps, worldToLocal?: Transform): ElementGeometryDataEntry | undefined; /** Apply transform directly to ElementGeometryDataEntry for a BRep */ function transformBRep(entry: ElementGeometryDataEntry, inputTransform: Transform): boolean; /** Update the supplied [[GeometryParams]] from an entry with appearance information */ function updateGeometryParams(entry: ElementGeometryDataEntry, geomParams: GeometryParams, localToWorld?: Transform): boolean; /** Append entries to represent a [[GeometryParams]] */ function appendGeometryParams(geomParams: GeometryParams, entries: ElementGeometryDataEntry[], worldToLocal?: Transform): boolean; /** Return entry as [[GeometryPart]] id and instance transform */ function toGeometryPart(entry: ElementGeometryDataEntry, partToElement?: Transform): Id64String | undefined; /** Create entry from a [[GeometryPart]] id and instance transform */ function fromGeometryPart(partId: Id64String, partTransform?: Transform, worldToLocal?: Transform): ElementGeometryDataEntry | undefined; /** Return entry as a [[ElementAlignedBox3d]] representing the local range of a geometric entry */ function toSubGraphicRange(entry: ElementGeometryDataEntry): ElementAlignedBox3d | undefined; /** Create entry from a [[ElementAlignedBox3d]] to compute and store local ranges for subsequent geometric entries */ function fromSubGraphicRange(bbox: ElementAlignedBox3d): ElementGeometryDataEntry | undefined; /** Create [[Transform]] from row-major storage 4x3 Float64Array */ function toTransform(sourceToWorld: Float64Array): Transform | undefined; /** Create [[ElementAlignedBox3d]] from lowX, lowY, lowZ, highX, highY, highZ Float64Array */ function toElementAlignedBox3d(bbox: Float64Array): ElementAlignedBox3d | undefined; } //# sourceMappingURL=ElementGeometry.d.ts.map