Interface MeasurementTypeAttachment

The MeasurementTypeAttachment interface defines a measurement result of a call to FeatureManagerInterface.computeMeasurement.

This interface defines the two contact points inside the two source features, and references the measurement request id returned by FeatureManagerInterface.computeMeasurement. It is included in the attachment of the FeatureManagerInterfaceSignal.MeasurementReady signal event. Valid measurement request ids are strictly positive integers.

/** 
 * 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

See

FeatureManagerInterface.computeMeasurement