Interface FeatureManagerInterface

The FeatureManagerInterface interface is the central point used to display features of 3D geometries, create custom features, retrieve Object Oriented Bounding Boxes of geometries and perform measurements between features.

Warning: if migrated from an old evojuump, features may not be available in the given DMU, since features have been added since the 4.1 version of the 3djuump architecture.

Features consist in lines, circles and patch borders (created with a given CAD model designing tool). The patch borders may be displayed with InfiniteEngineInterface.enablePatchBorders or InfiniteEngineInterface.setPatchBordersEnabled.

The FeatureManagerInterface is obtained through the InfiniteEngineInterface.getFeatureManager.

Display features of 3D geometries

Features of specific geometric instances may be displayed (FeatureManagerInterface.setGeometricInstancesFeaturesVisible, FeatureManagerInterface.setGeometricInstanceFeaturesVisible) and then are available in picking requests. Line and arc of circles inside the given 3D geometries will then be displayed, and all lines /arc of circle rendering are also conditioned to the value of the given FeatureVisibilityMode.

Features rendering modes are modified and retrieved with FeatureManagerInterface.setGeometricInstancesFeaturesTypesVisibility and FeatureManagerInterface.getGeometricInstancesFeaturesTypesVisibility.

This may be :

• All geometric features visible : FeatureVisibilityMode.FVM_All.
• Only geometric circular features visible : FeatureVisibilityMode.FVM_ArcOfCircle.
• Only geometric line features visible : FeatureVisibilityMode.FVM_Line.
• None geometric features visible: FeatureVisibilityMode.FVM_None.

This enum is a bit field, meaning that to display line data and circular features, use FeatureVisibilityMode.FVM_ArcOfCircle | FeatureVisibilityMode.FVM_Line.

The default FeatureVisibilityMode is FeatureVisibilityMode.FVM_All.

Showing feature elements may be done through the following:

/** 
 * Sample to illustrate the showing of the circle `features` of some geometric instances.
 */
import { FeatureManagerInterface, FeatureVisibilityMode, InfiniteEngineInterface } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instances to show `features`
let lGeometricInstanceIds : Array<number> | Uint32Array;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();

// display only circles of geometries
lFeatureManager.setGeometricInstancesFeaturesTypesVisibility(FeatureVisibilityMode.FVM_ArcOfCircle);

// hide all previously displayed `features` 
lFeatureManager.clearGeometricInstanceFeaturesVisible();

// and show the `features` of the given geometries
lFeatureManager.setGeometricInstancesFeaturesVisible(lGeometricInstanceIds, true);

Copy

/** 
 * Sample to illustrate the showing of the line `features` of some geometric instances.
 */
import { FeatureManagerInterface, FeatureVisibilityMode, InfiniteEngineInterface } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instances to show `features`
let lGeometricInstanceIds : Array<number> | Uint32Array;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();

// display only lines of geometries
lFeatureManager.setGeometricInstancesFeaturesTypesVisibility(FeatureVisibilityMode.FVM_Line);

// hide all previously displayed `features` 
lFeatureManager.clearGeometricInstanceFeaturesVisible();

// and show the `features` of the given geometries
lFeatureManager.setGeometricInstancesFeaturesVisible(lGeometricInstanceIds, true);

Copy

Displayed `features` are `hover-able` and the FeatureManagerInterfaceSignal.FeatureHoverChanged is sent whenever a `feature` under the cursor changes.

Custom Feature creation

Multiple features may be created and displayed. Arcs of circle, lines, points and OOBBs may be created and displayed. Features must be register onto the FeatureManagerInterface and are assigned a unique strictly positive integer (an id). Features may be created by createApplicationFeatureFromFeature, and made visible / hidden with setApplicationFeaturesVisible. Features may be removed with removeApplicationFeature, removeApplicationFeatures and removeAllApplicationFeatures. Features are composed of a type (FeatureItem.type, FeatureType) and data that is dependent on the type of the feature.

Arcs of circle (FeatureType.FT_ArcOfCircle)

A full circle feature is represented with a center, a normal, and a radius. If added with an optional starting direction and an angle, the feature will represent only a part of a circle (arc of circle). The arc of circle is represented by the point positioned P0 = Center + radius * startDirection. Then compute the point P1 which is the rotation of P0 of the given angle from Center along the axis Normal. Positive angles between P0 and P1 are the points that belong to the arc of circle. Negative angles are set to 0 (thus a point). Angles superior to 2 * PI are cropped to 2 * PI.

Arcs of circle are created through createCircularArcApplicationFeature.

/** 
 * Sample to illustrate the creation and display of a circle `feature`.
 */
import { FeatureManagerInterface, InfiniteEngineInterface, Vector3 } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();

const createArcFeature = () : void =>
{
    // the circle application id
    const lFeatureCircleApplicationId : number = lFeatureManager.createCircularArcApplicationFeature(
        new Vector3(1, 1, 1),
        50,
        new Vector3(1, 0, 0),
        new Vector3(0, 1, 0),
        Math.PI * 2
    );

    if(lFeatureCircleApplicationId <= 0)
    {
        return;
    }

    // do something ...

    // and later make it invisible
    lFeatureManager.setApplicationFeatureVisible(lFeatureCircleApplicationId, false);

    // do something ...

    // and put back visible
    lFeatureManager.setApplicationFeatureVisible(lFeatureCircleApplicationId, true);
};

createArcFeature();

Copy

Lines (FeatureType.FT_Line)

Lines are represented by two points (Vector3).

Lines are created through createLineApplicationFeature.

/** 
 * Sample to illustrate the creation and display of a line `feature`.
 */
import { FeatureManagerInterface, InfiniteEngineInterface, Vector3 } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();

const createLineFeature = () : void =>
{
    // the line application id
    const lFeatureLineApplicationId : number = lFeatureManager.createLineApplicationFeature(
        new Vector3(1, 1, 1),
        new Vector3(100, 1, 1),
    );

    if(lFeatureLineApplicationId <= 0)
    {
        return;
    }

    // do something ...

    // and later make it invisible
    lFeatureManager.setApplicationFeatureVisible(lFeatureLineApplicationId, false);

    // do something ...

    // and put back visible
    lFeatureManager.setApplicationFeatureVisible(lFeatureLineApplicationId, true);
};

createLineFeature();

Copy

Points (FeatureType.FT_Point)

Points are represented by a lone Vector3.

Points are created through createPointApplicationFeature.

/** 
 * Sample to illustrate the creation and display of a point `feature`.
 */
import { FeatureManagerInterface, InfiniteEngineInterface, Vector3 } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();

const createPointFeature = () : void =>
{
    // the point application id
    const lFeaturePointApplicationId : number = lFeatureManager.createPointApplicationFeature(
        new Vector3(1, 1, 1),
    );

    if(lFeaturePointApplicationId <= 0)
    {
        return;
    }

    // do something ...

    // and later make it invisible
    lFeatureManager.setApplicationFeatureVisible(lFeaturePointApplicationId, false);

    // do something ...

    // and put back visible
    lFeatureManager.setApplicationFeatureVisible(lFeaturePointApplicationId, true);
};

createPointFeature();

Copy

OOBBs (FeatureType.FT_OOBB)

Object Oriented Bounding Boxes (OOBB) are similar to Axis Aligned Bounding Boxes (AABB) but with 3 axes that may not be axis aligned. OOBB are a lot more precise that AABB.

OOBBs can be displayed with createOOBBApplicationFeature.

/** 
 * Sample to illustrate the retrieval of the OOBB of a geometry.
 */
import { FeatureManagerInterface, FeatureManagerInterfaceSignal, InfiniteEngineInterface, InfiniteEvent, OOBB, OOBBTypeAttachment } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instance to retrieve OOBB from
let lGeometricInstanceId : number;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();
// the OOBB request id
let lRetrieveOobbRequestId : number = 0;

// the resulting OOBB
let lOobbResult : OOBB | undefined = undefined;

// the callback called when a OOBB result is ready
const onOobbRetrieved = (pEvent: InfiniteEvent) : void =>
{
    const lOOBBAttachment : OOBBTypeAttachment | undefined = pEvent.attachments;
    // is this event valid ?
    if(lOOBBAttachment === undefined || lOOBBAttachment.oobb === undefined)
    {
        console.log('invalid oobb attachment');
        return;
    }
    // is this the correct request ?
    if(lOOBBAttachment.oobbRequestId !== lRetrieveOobbRequestId)
    {
        // 
        return;
    }
    // finally, we made it !
    lOobbResult = lOOBBAttachment.oobb;
    console.log('Found oobb', JSON.stringify(lOobbResult));
    const lApplicationId : number = lFeatureManager.createOOBBApplicationFeature(lOobbResult);
    if(lApplicationId <= 0)
    {
        console.log('feature creation failed');
    }
};

// register our callback
lFeatureManager.addEventListener(FeatureManagerInterfaceSignal.OOBBReady, onOobbRetrieved);

// and request an oobb
lRetrieveOobbRequestId = lFeatureManager.retrieveOOBB(lGeometricInstanceId);
if(lRetrieveOobbRequestId <= 0)
{
    console.log('Failed to query oobb, is the geometric instance id correct ?');
}

Copy

Object Oriented Bounding Boxes retrieval

Object Oriented Bounding Boxes (OOBB are similar to Axis Aligned Bounding Boxes (AABB) but with 3 axes that may not be axis aligned. The OOBB are a lot more precise that AABB. The OOBB retrieval is asynchronous, each request is assigned an integer id (a strictly positive integer) while calling retrieveOOBB. The FeatureManagerInterfaceSignal.OOBBReady signal is triggered when a request has completed.

/** 
 * Sample to illustrate the retrieval of the OOBB of a geometry.
 */
import { FeatureManagerInterface, FeatureManagerInterfaceSignal, InfiniteEngineInterface, InfiniteEvent, OOBB, OOBBTypeAttachment } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instance to retrieve OOBB from
let lGeometricInstanceId : number;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();
// the OOBB request id
let lRetrieveOobbRequestId : number = 0;

// the resulting OOBB
let lOobbResult : OOBB | undefined = undefined;

// the callback called when a OOBB result is ready
const onOobbRetrieved = (pEvent: InfiniteEvent) : void =>
{
    const lOOBBAttachment : OOBBTypeAttachment | undefined = pEvent.attachments;
    // is this event valid ?
    if(lOOBBAttachment === undefined || lOOBBAttachment.oobb === undefined)
    {
        console.log('invalid oobb attachment');
        return;
    }
    // is this the correct request ?
    if(lOOBBAttachment.oobbRequestId !== lRetrieveOobbRequestId)
    {
        // 
        return;
    }
    // finally, we made it !
    lOobbResult = lOOBBAttachment.oobb;
    console.log('Found oobb', JSON.stringify(lOobbResult));
    const lApplicationId : number = lFeatureManager.createOOBBApplicationFeature(lOobbResult);
    if(lApplicationId <= 0)
    {
        console.log('feature creation failed');
    }
};

// register our callback
lFeatureManager.addEventListener(FeatureManagerInterfaceSignal.OOBBReady, onOobbRetrieved);

// and request an oobb
lRetrieveOobbRequestId = lFeatureManager.retrieveOOBB(lGeometricInstanceId);
if(lRetrieveOobbRequestId <= 0)
{
    console.log('Failed to query oobb, is the geometric instance id correct ?');
}

Copy

/** 
 * Sample to illustrate the asynchronous retrieval of the OOBB of a geometry.
 */
import { FeatureManagerInterface, InfiniteEngineInterface, OOBBAsyncResult } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instance to retrieve OOBB from
let lGeometricInstanceId : number;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();

const fetchOobb = async () : Promise<void> =>
{
    const lOobbResult : OOBBAsyncResult = await lFeatureManager.asyncRetrieveOOBB(lGeometricInstanceId);

    if(lOobbResult.value === undefined || lOobbResult.value.oobb === undefined)
    {
        console.log('Failed to query oobb, is the geometric instance id correct ?');
        return;
    }
    console.log('Found oobb', JSON.stringify(lOobbResult.value));
    const lApplicationId : number = lFeatureManager.createOOBBApplicationFeature(lOobbResult.value.oobb);
    if(lApplicationId <= 0)
    {
        console.log('feature creation failed');
    }
};

// trigger the OOBB retrieval
fetchOobb();

Copy

Measurements

Minimal distance between features can be computed. A distance computation consists in two contact points, one for each feature. 2 more features, that cannot be displayed are used for performing computations. A measure is computed between two features, and a modifier is used to accurately define the measurement between the 2 features. The modifier is of the type MeasurementType. This allows to tell if the measurement should be processed from all the points of a feature or only the center of it (you may for example perform a measurement between the center of 2 geometries, more on this later).

/** 
 * Sample to illustrate the retrieval of the OOBB of a geometry.
 */
import { FeatureManagerInterface, FeatureManagerInterfaceSignal, InfiniteEngineInterface, InfiniteEvent, OOBB, OOBBTypeAttachment } from 'generated_files/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instance to retrieve OOBB from
let lGeometricInstanceId : number;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();
// the OOBB request id
let lRetrieveOobbRequestId : number = 0;

// the resulting OOBB
let lOobbResult : OOBB | undefined = undefined;

// the callback called when a OOBB result is ready
const onOobbRetrieved = (pEvent: InfiniteEvent) : void =>
{
    const lOOBBAttachment : OOBBTypeAttachment | undefined = pEvent.attachments;
    // is this event valid ?
    if(lOOBBAttachment === undefined || lOOBBAttachment.oobb === undefined)
    {
        console.log('invalid oobb attachment');
        return;
    }
    // is this the correct request ?
    if(lOOBBAttachment.oobbRequestId !== lRetrieveOobbRequestId)
    {
        // 
        return;
    }
    // finally, we made it !
    lOobbResult = lOOBBAttachment.oobb;
    console.log('Found oobb', JSON.stringify(lOobbResult));
    const lApplicationId : number = lFeatureManager.createOOBBApplicationFeature(lOobbResult);
    if(lApplicationId <= 0)
    {
        console.log('feature creation failed');
    }
};

// register our callback
lFeatureManager.addEventListener(FeatureManagerInterfaceSignal.OOBBReady, onOobbRetrieved);

// and request an oobb
lRetrieveOobbRequestId = lFeatureManager.retrieveOOBB(lGeometricInstanceId);
if(lRetrieveOobbRequestId <= 0)
{
    console.log('Failed to query oobb, is the geometric instance id correct ?');
}

Copy

/** 
 * Sample to illustrate the measurement between a geometry and an arc of circle.
 */
import {
    AABB, ArcOfCircleFeature, DataSessionInterface, FeatureManagerInterface, FeatureManagerInterfaceSignal,
    FeatureType, GeometryFeature, InfiniteEngineInterface, InfiniteEvent, MeasurementType, MeasurementTypeAttachment,
    Unit, Vector3
} from 'generated_files/documentation/appinfiniteapi';

// the data session
// created previously
let lDataSession : DataSessionInterface;

// created previously
let lInfiniteEngine : InfiniteEngineInterface;

// the geometric instance to compute measurement from
let lGeometricInstanceId : number;

// retrieve the `feature` manager
const lFeatureManager : FeatureManagerInterface = lInfiniteEngine.getFeatureManager();
// the measurement request id
let lMeasurementRequestId : number = 0;

// the callback called when a measurement result is ready
const onMeasurementDone = (pEvent: InfiniteEvent) : void =>
{
    const lMeasurementAttachment : MeasurementTypeAttachment | undefined = pEvent.attachments;
    // is this event valid ?
    if(lMeasurementAttachment === undefined || lMeasurementAttachment.contactPoint0 === undefined)
    {
        console.log('invalid measurement attachment');
        return;
    }
    // is this the correct request ?
    if(lMeasurementAttachment.measurementRequestId !== lMeasurementRequestId)
    {
        // bail out
        return;
    }
    // finally, we made it !
    console.log('Found 2 contact points', JSON.stringify(lMeasurementAttachment.contactPoint0), JSON.stringify(lMeasurementAttachment.contactPoint1));

    // make two fancy points on the rendering
    let lApplicationId : number = lFeatureManager.createPointApplicationFeature(lMeasurementAttachment.contactPoint0);
    if(lApplicationId <= 0)
    {
        console.log('feature creation failed');
    }
    lApplicationId = lFeatureManager.createPointApplicationFeature(lMeasurementAttachment.contactPoint1);
    if(lApplicationId <= 0)
    {
        console.log('feature creation failed');
    }
    // and show the result, we are here for that
    console.log('Measurement distance', lMeasurementAttachment.contactPoint0.distanceToVector(lMeasurementAttachment.contactPoint1));
};

// register our callback
lFeatureManager.addEventListener(FeatureManagerInterfaceSignal.MeasurementReady, onMeasurementDone);

// retrieve the DMU center
const lDmuAABB : AABB = new AABB();
lDataSession.getDmuAABB(lDmuAABB);

// retrieve the up and front vectors of the scene
const lDmuUpVector : Vector3 = new Vector3();
const lDmuFrontVector : Vector3 = new Vector3();
lInfiniteEngine.getCameraManager().getFrameReference(lDmuFrontVector, lDmuUpVector);

// the arc of circle radius in meters
const lCircleFeatureRadiusInMeters : number = 1.3;

// first `feature` is a geometry
const lFirstFeature : GeometryFeature = {
    type: FeatureType.FT_Geometry,
    geometricInstanceId: lGeometricInstanceId
};

// second `feature` is an arc of circle
const lSecondFeature : ArcOfCircleFeature = {
    type: FeatureType.FT_ArcOfCircle,
    center: lDmuAABB.mCenter,
    normal: lDmuUpVector,
    startDirection: lDmuFrontVector,
    radius: lCircleFeatureRadiusInMeters * lDataSession.convertUnitFactor(Unit.U_Meter, lDataSession.getDmuBuildUnit()),
    angle: Math.PI * 0.5
};

// and make a measurement between the geometry and the given arc of circle (do not use item centers)
// the measure is the smallest distance between the 2 elements
lMeasurementRequestId = lFeatureManager.computeMeasurement(lFirstFeature, lSecondFeature, MeasurementType.MT_Item_Item);
if(lMeasurementRequestId <= 0)
{
    console.log('Failed to make measurement, is the geometric instance id correct ?');
}

Copy

Geometry features (FeatureType.FT_Geometry)

A geometry feature is a feature that contains a geometric instance id. Distance between geometries can be processed with geometry features. Geometry features cannot be displayed since geometries are already displayed :).

Plane features (FeatureType.FT_Plane)

A plane feature is a feature that contains a position and a normal. Plane features cannot be displayed.

See

OOBB