Enumeration AnnotationInstanceState

The AnnotationInstanceState enum tells about the way annotations should be rendered.

The way annotations are rendered is set by a number which is an OR of multiple bit flags. Usually, annotations are hidden below a geometry if it is behind the given geometry.

• Annotations are contained in three bucket lists of increasing importance : low, standard and high. Annotations in a more important buckets are rendered on top of annotations in a lower importance bucket, regardless of their depth (AIS_DepthPriorityLow, AIS_DepthPriorityStd, AIS_DepthPriorityHigh).
• Annotations can be visible or hidden (AIS_Visible).
• Annotations can be set to be visible even if a geometry is above it (AIS_Overprint).
• Annotations can be set to be visible if it is behind a geometry but with a desaturated color (AIS_AppearThroughGeometry).
• Annotations color can be changed to be pulsing (AIS_Highlight), usually to tell it is selected.

In order to avoid setting bits that should not be changed and leave them unchanged, annotations rendering bits are set with a mask telling which bits should be changed. This system allows to change the way annotation are rendered in a single call.

Displaying annotations may be done with the following :

/** 
 * Sample to illustrate the displaying of annotations.
 */
import {
    AnnotationGetterInterface, AnnotationGetterInterfaceSignal, InfiniteEvent,
    AnnotationResultInterface, InfiniteEngineInterface, AnnotationRendererInterface, AnnotationRendererInterfaceSignal,
    tAnnotationViewId, AnnotationInstanceState, AnnotationViewParsingResultInterface, AnnotationViewInterface
} from 'generated_files/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.getAnnotationGroupsResult();
    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 lAnnotationViews : Array<AnnotationViewInterface> = lAnnotationResult.getAnnotationViews();
    if(lAnnotationViews.length === 0)
    {
        console.log('Weird, annotation is downloaded but no result');
        return;
    }
    const lMask : number = AnnotationInstanceState.AIS_DepthPriorityMask | AnnotationInstanceState.AIS_Visible;
    const lState : number = AnnotationInstanceState.AIS_DepthPriorityStd;
    const lRequestId : number = lAnnotationRenderer.addAnnotationView(lAnnotationViews[0], lAnnotationResult.getGroupMatrix(), 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.annotationView === undefined)
    {
        // this is an error
        console.log('annotation view parsing has failed ' + JSON.stringify(lParsingResult.error));
        return;
    }

    // store the annotation view id
    lAnnotationViewId = lParsingResult.annotationView.getViewId();
    const lNbAnnotations : number = lParsingResult.annotationView.getAnnotationsCount();
    const lAnnotationStartId : number = lParsingResult.annotationView.getFirstAnnotationId();
    // create the list of annotation ids from lParsingResult.annotationIdStart to lParsingResult.annotationIdStart + lParsingResult.nbAnnotations - 1
    const lAnnotationIds : number [] = [];
    lAnnotationIds.length = lNbAnnotations;
    let i : number;
    for (i = 0; i < lNbAnnotations; i += 1)
    {
        lAnnotationIds[i] = lAnnotationStartId + 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
};

Copy

Please see Annotations for more explanations about annotations.