Interface AnnotationViewInterface

The AnnotationViewInterface interface contains the annotations data of an annotation view.

Please see Annotations for more explanations about annotations.

The AnnotationViewInterface features a 3D plane (X axis, Y Axis, Normal, Origin) from which 2D data (texts, 2D shapes, images) are positioned. The AnnotationViewInterface represents a set of annotations (Functional Tolerancing and Annotations, Product Manufacturing Information, Measures, etc ...) placed in a 3D plane. AnnotationViewInterfaces should be included in the AnnotationRendererInterface.

The AnnotationViewInterface is retrieved from an AnnotationResultInterface that was fetched from an AnnotationGetterInterface.

Below is some code to retrieve an AnnotationViewInterface from an id card request.

/** 
 * Sample to illustrate the use of an AnnotationGetterInterface to retrieve multiple annotation views.
 */
import {
    DataSessionInterface, IdCardGetterInterface, IdCardGetterInterfaceSignal,
    InfiniteEvent, PartInstanceInfoInterface, AnnotationViewInfoInterface, AnnotationGetterInterface, AnnotationGetterInterfaceSignal, AnnotationResultInterface, VisibilityContextInterface,
} from 'generated/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// created previously
let lIdCardGetterInterface : IdCardGetterInterface;
// created previously, the visibility context to use for the id card query
let lVisibilityContext : VisibilityContextInterface;
// the part instance id to fetch
let lPartInstanceId : number;

// to retrieve the annotations
const lAnnotationViewGetter : AnnotationGetterInterface = lDataSession.createAnnotationGetter();

// what to do when we have retrieved id card information ?
let onIdCardReady : (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) => void;

// what to do when annotation data has been downloaded ?
let onAnnotationViewDownloaded : (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) => void;

// what to do when id card is ready ?
lIdCardGetterInterface.addEventListener(IdCardGetterInterfaceSignal.IdCardReady, onIdCardReady);
// what to do when the download of the annotation view is ready ?
lAnnotationViewGetter.addEventListener(AnnotationGetterInterfaceSignal.AnnotationFetchReady, onAnnotationViewDownloaded);

// onIdCardReady will be called when idcard data is available
onIdCardReady = (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    if (lIdCardGetterInterface.getLastError().length !== 0) {
        // do nothing in case of error
        // perhaps some GUI code ?
    }
    const lPartInstanceInfos : Array<PartInstanceInfoInterface> | undefined = lIdCardGetterInterface.getPartInstanceInfos();
    if (!lPartInstanceInfos || lPartInstanceInfos.length !== 1)
    {
        // no data (isCancelled ?)
        return;
    }
    // get the first the instantiation chain
    const lCurrentChain : PartInstanceInfoInterface = lPartInstanceInfos[0];
    // the annotation views that will be fetched
    const lAnnotationsToFetch : Array<AnnotationViewInfoInterface> = [];
    // iterate over the annotation views to retrieve all views at once
    const lAllAnnotationViews : Array<Array<AnnotationViewInfoInterface>> = lCurrentChain.getAnnotationViews();
    // loops
    let i : number;
    let j : number;
    // number of annotation views for this instance
    let lNbAnnotationViews : number;
    // number of ancestors
    const lNbAncestors : number = lAllAnnotationViews.length;
    let lAnnotationViewsOfPartInstance :Array<AnnotationViewInfoInterface>;
    let lCurAnnotationView : AnnotationViewInfoInterface;
    for (i = 0; i < lNbAncestors; ++i)
    {
        lAnnotationViewsOfPartInstance = lAllAnnotationViews[i];
        lNbAnnotationViews = lAnnotationViewsOfPartInstance.length;
        for (j = 0; j < lNbAnnotationViews; ++j)
        {
            lCurAnnotationView = lAnnotationViewsOfPartInstance[j];
            // some fancy log
            console.log('Will fetch annotation view ' + lCurAnnotationView.getAnnotationViewName() + ' of type ' + lCurAnnotationView.getAnnotationViewTypeName()
                    + ' with ' + lCurAnnotationView.getAnnotationViewAnnotationCount() + ' annotations');
            // add the annotation view to be fetched
            lAnnotationsToFetch.push(lCurAnnotationView);
        }
    }
    // and download
    lAnnotationViewGetter.fetchAnnotationViews(lAnnotationsToFetch);
}

// what to do when annotation data has been downloaded ?
onAnnotationViewDownloaded = (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    // annotation are ready
    const lAnnotationViewsContent : Array<AnnotationResultInterface> | undefined = lAnnotationViewGetter.getAnnotationViewsResult();
    if ((!lAnnotationViewsContent) || (lAnnotationViewsContent.length === 0))
    {
        console.log('error while fetching annotation content');
        return;
    }
    // now annotation content is there, just need to display them
    // use only the first view
    const lCurAnnotationViewResult : AnnotationResultInterface = lAnnotationViewsContent[0];
    console.log('display annotation view ' + lCurAnnotationViewResult.getAnnotationViewName() + ' (of type ' + lCurAnnotationViewResult.getAnnotationViewTypeName() + ')');
}

lIdCardGetterInterface.retrieveIdCard(lPartInstanceId, lVisibilityContext);

or with async calls :

/** 
 * Sample to illustrate the asynchronous use of an AnnotationGetterInterface to retrieve multiple annotation views.
 */
import {
    DataSessionInterface, IdCardGetterInterface, VisibilityContextInterface, AsyncResultReason, AsyncPartInstanceInfoResult,
    PartInstanceInfoInterface, AnnotationViewInfoInterface, AnnotationGetterInterface, AnnotationResultInterface, AsyncAnnotationResult
} from 'generated/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;
// created previously
let lIdCardGetterInterface : IdCardGetterInterface;
// created previously, the visibility context to use for the id card query
let lVisibilityContext : VisibilityContextInterface;
// the part instance id to fetch
let lPartInstanceId : number;

// to retrieve the annotations
const lAnnotationViewGetter : AnnotationGetterInterface = lDataSession.createAnnotationGetter();

const fetchAnnotation = async () : Promise<any> =>
{
    const lIdCardRes : AsyncPartInstanceInfoResult = await lIdCardGetterInterface.asyncRetrieveIdCard(lPartInstanceId, lVisibilityContext);
    if (!lIdCardRes.value || !lIdCardRes.value.length)
    {
        // display some fancy error message
        return;
    }
    console.assert(lIdCardRes.reason === AsyncResultReason.ARR_Success);

    // get the first the instantiation chain
    const lCurrentChain : PartInstanceInfoInterface = lIdCardRes.value[0];
    // the annotation views that will be fetched
    const lAnnotationsToFetch : Array<AnnotationViewInfoInterface> = [];
    // iterate over the annotation views to retrieve all views at once
    const lAllAnnotationViews : Array<Array<AnnotationViewInfoInterface>> = lCurrentChain.getAnnotationViews();
    // loops
    let i : number;
    let j : number;
    // number of annotation views for this instance
    let lNbAnnotationViews : number;
    // number of ancestors
    const lNbAncestors : number = lAllAnnotationViews.length;
    let lAnnotationViewsOfPartInstance :Array<AnnotationViewInfoInterface>;
    let lCurAnnotationView : AnnotationViewInfoInterface;
    for (i = 0; i < lNbAncestors; ++i)
    {
        lAnnotationViewsOfPartInstance = lAllAnnotationViews[i];
        lNbAnnotationViews = lAnnotationViewsOfPartInstance.length;
        for (j = 0; j < lNbAnnotationViews; ++j)
        {
            lCurAnnotationView = lAnnotationViewsOfPartInstance[j];
            // some fancy log
            console.log('Will fetch annotation view ' + lCurAnnotationView.getAnnotationViewName() + ' of type ' + lCurAnnotationView.getAnnotationViewTypeName()
                    + ' with ' + lCurAnnotationView.getAnnotationViewAnnotationCount() + ' annotations');
            // add the annotation view to be fetched
            lAnnotationsToFetch.push(lCurAnnotationView);
        }
    }
    // and download
    const lAnnotationContentResult : AsyncAnnotationResult = await lAnnotationViewGetter.asyncFetchAnnotationViews(lAnnotationsToFetch);
    // annotation are ready
    // const lAnnotationViewsContent : Array<AnnotationResultInterface> | undefined = lAnnotationViewGetter.getAnnotationViewsResult();
    if ((!lAnnotationContentResult.value) || (lAnnotationContentResult.value.length === 0))
    {
        console.log('error while fetching annotation content');
        return;
    }
    // now annotation content is there, just need to display them
    // use only the first view
    const lCurAnnotationViewResult : AnnotationResultInterface = lAnnotationContentResult.value[0];
    console.log('display annotation view ' + lCurAnnotationViewResult.getAnnotationViewName() + ' (of type ' + lCurAnnotationViewResult.getAnnotationViewTypeName() + ')');
}

fetchAnnotation();

Once retrieved, an AnnotationViewInterface may be included in an [AnnotationRendererInterface](AnnotationRendererInterface.html) to be displayed.

/** 
 * Sample to illustrate the displaying of annotations.
 */
import {
    AnnotationGetterInterface, AnnotationGetterInterfaceSignal, InfiniteEvent,
    AnnotationResultInterface, Matrix4, InfiniteEngineInterface, AnnotationRendererInterface, AnnotationRendererInterfaceSignal,
    tAnnotationViewId, AnnotationInstanceState, AnnotationViewParsingResultInterface,
} from 'generated/documentation/appinfiniteapi';

// created previously
let lAnnotationViewGetter : AnnotationGetterInterface;
// created previously
let lInfiniteEngine : InfiniteEngineInterface;
// retrieve the annotation renderer
const lAnnotationRenderer : AnnotationRendererInterface = lInfiniteEngine.getAnnotationRenderer();

// the annotation view id that has just been parsed
let lAnnotationViewId : tAnnotationViewId = -1;

// what to do when an annotation has been downloaded ?
let onAnnotationRetrieved : (pEvent: InfiniteEvent, pCallbackData: Object | undefined) => void;

// what to do when an annotation is ready to be displayed ?
let onAnnotationReady : (pEvent: InfiniteEvent, pCallbackData: Object | undefined) => void;

// connect to signals
lAnnotationViewGetter.addEventListener(AnnotationGetterInterfaceSignal.AnnotationFetchReady, onAnnotationRetrieved);
lAnnotationRenderer.addEventListener(AnnotationRendererInterfaceSignal.AnnotationViewParsed, onAnnotationReady);

// what to do when an annotation has been downloaded ?
onAnnotationRetrieved = (_pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    // the result of the download
    const lAnnotationViewsContent : Array<AnnotationResultInterface> | undefined = lAnnotationViewGetter.getAnnotationViewsResult();
    if (!lAnnotationViewsContent || (lAnnotationViewsContent.length === 0))
    {
        console.log('Weird, annotation is downloaded but no content');
        return;
    }
    if (lAnnotationViewsContent.length > 1)
    {
        console.log('Only displaying one annotation view at the moment, other annotation views will be discarded');
        return;
    }
    // take the first annotation result, discarding others
    const lAnnotationResult : AnnotationResultInterface = lAnnotationViewsContent[0];

    // and add the annotation view to be displayed with standard depth
    // we want to set the depth and visible state of the annotation
    // mask is AnnotationInstanceState.AIS_DepthPriorityMask | AnnotationInstanceState.AIS_Visible
    // but we want to be depth std and invisible
    // state is AnnotationInstanceState.AIS_DepthPriorityStd | 0 = AnnotationInstanceState.AIS_DepthPriorityStd

    const lMask : number = AnnotationInstanceState.AIS_DepthPriorityMask | AnnotationInstanceState.AIS_Visible;
    const lState : number = AnnotationInstanceState.AIS_DepthPriorityStd;
    const lRequestId : number = lAnnotationRenderer.addAnnotationView(lAnnotationResult.getAnnotationView(), lAnnotationResult.getAnnotationViewMatrix(), lMask, lState);
    if (lRequestId < 0)
    {
        // weird error
        console.log('The parsing procedure could not be started');
    }
}

// what to do when an annotation is ready to be displayed ?
onAnnotationReady = (pEvent: InfiniteEvent, _pCallbackData: Object | undefined) : void =>
{
    // fancy log
    console.log('annotation view has finished parsing');

    // take the parsing result
    const lParsingResult : AnnotationViewParsingResultInterface = pEvent.attachments;
    if (lParsingResult.annotationViewId < 0)
    {
        // this is an error
        console.log('annotation view parsing has failed ' + lParsingResult.errorMessage);
        return;
    }

    // store the annotation view id
    lAnnotationViewId = lParsingResult.annotationViewId;

    // create the list of annotation ids from lParsingResult.annotationIdStart to lParsingResult.annotationIdStart + lParsingResult.nbAnnotations - 1
    const lAnnotationIds : number [] = [];
    lAnnotationIds.length = lParsingResult.nbAnnotations;
    let i : number;
    for (i = 0; i < lParsingResult.nbAnnotations; ++i)
    {
        lAnnotationIds[i] = lParsingResult.annotationIdStart + i;
    }
    // mask for all rendering flags (except priority)
    const lMask : number = AnnotationInstanceState.AIS_AppearThroughGeometry | AnnotationInstanceState.AIS_Highlight
                | AnnotationInstanceState.AIS_Overprint | AnnotationInstanceState.AIS_Visible;
    // state is visible (but we may add AnnotationInstanceState.AIS_AppearThroughGeometry just for fun)
    const lState : number = AnnotationInstanceState.AIS_Visible; // | AnnotationInstanceState.AIS_AppearThroughGeometry

    lAnnotationRenderer.setAnnotationRenderingState(lAnnotationIds, lMask, lState);
    // you should now see the annotation on the next rendering
}

Or asynchronously :

/** 
 * Sample to illustrate the asynchronous displaying of annotations.
 */
import {
    AnnotationGetterInterface,
    AnnotationResultInterface, AnnotationViewInfoInterface, InfiniteEngineInterface, AnnotationRendererInterface,
    tAnnotationViewId, AnnotationInstanceState, AnnotationViewParsingResultInterface, AsyncAnnotationResult, AsyncResultReason
} from 'generated/documentation/appinfiniteapi';

// created previously
let lAnnotationViewGetter : AnnotationGetterInterface;
// created previously
let lInfiniteEngine : InfiniteEngineInterface;
// retrieve the annotation renderer
const lAnnotationRenderer : AnnotationRendererInterface = lInfiniteEngine.getAnnotationRenderer();
// the annotation to fetch
let lAnnotationToFetch : AnnotationViewInfoInterface;

// the annotation view id that has just been parsed
let lAnnotationViewId : tAnnotationViewId = -1;

const displayResult = async () : Promise<any> =>
{
    const lAsyncAnnotationResult : AsyncAnnotationResult = await lAnnotationViewGetter.asyncFetchAnnotationViews(lAnnotationToFetch);

    // the result of the download
    const lAnnotationViewsContent : Array<AnnotationResultInterface> | undefined = lAsyncAnnotationResult.value;
    if (!lAnnotationViewsContent || (lAnnotationViewsContent.length === 0))
    {
        console.log('Weird, annotation download error');
        return;
    }
    if (lAnnotationViewsContent.length > 1)
    {
        console.log('Weird, annotation is downloaded but too many results');
        return;
    }
    // take the first annotation result, discarding others
    const lAnnotationResult : AnnotationResultInterface = lAnnotationViewsContent[0];

    // and add the annotation view to be displayed with standard depth
    // we want to set the depth and visible state of the annotation
    // mask is AnnotationInstanceState.AIS_DepthPriorityMask | AnnotationInstanceState.AIS_Visible
    // but we want to be depth std and invisible
    // state is AnnotationInstanceState.AIS_DepthPriorityStd | 0 = AnnotationInstanceState.AIS_DepthPriorityStd
    let lMask : number = AnnotationInstanceState.AIS_DepthPriorityMask | AnnotationInstanceState.AIS_Visible;
    let lState : number = AnnotationInstanceState.AIS_DepthPriorityStd;
    const lAnnotationParsingResult = await lAnnotationRenderer.asyncAddAnnotationView(lAnnotationResult.getAnnotationView(), lAnnotationResult.getAnnotationViewMatrix(), lMask, lState);

    if (lAnnotationParsingResult.reason !== AsyncResultReason.ARR_Success
        || lAnnotationParsingResult.value === undefined)
    {
        // weird error
        console.log('The parsing procedure could not be started');
        return;
    }
    // fancy log
    console.log('annotation view has finished parsing');

    // take the parsing result
    const lParsingResult : AnnotationViewParsingResultInterface = lAnnotationParsingResult.value;
    if (lParsingResult.annotationViewId < 0)
    {
        // this is an error
        console.log('annotation view parsing has failed ' + lParsingResult.errorMessage);
        return;
    }

    // store the annotation view id
    lAnnotationViewId = lParsingResult.annotationViewId;

    // create the list of annotation ids from lParsingResult.annotationIdStart to lParsingResult.annotationIdStart + lParsingResult.nbAnnotations - 1
    const lAnnotationIds : number [] = [];
    lAnnotationIds.length = lParsingResult.nbAnnotations;
    let i : number;
    for (i = 0; i < lParsingResult.nbAnnotations; ++i)
    {
        lAnnotationIds[i] = lParsingResult.annotationIdStart + i;
    }
    // mask for all rendering flags (except priority)
    lMask = AnnotationInstanceState.AIS_AppearThroughGeometry | AnnotationInstanceState.AIS_Highlight
                | AnnotationInstanceState.AIS_Overprint | AnnotationInstanceState.AIS_Visible;
    // state is visible (but we may add AnnotationInstanceState.AIS_AppearThroughGeometry just for fun)
    lState = AnnotationInstanceState.AIS_Visible; // | AnnotationInstanceState.AIS_AppearThroughGeometry

    lAnnotationRenderer.setAnnotationRenderingState(lAnnotationIds, lMask, lState);
    // you should now see the annotations on the next rendering
}

displayResult();

Please make sure the destination browser supports promises before using async calls.

See

• AnnotationGetterInterface
• AnnotationRendererInterface
• AnnotationResultInterface