Interface FilterAABBInterface

The FilterAABBInterface interface is a FilterItemInterface to elect part instances intersecting an axis aligned box.

The inclusion algorithm may be strict, i.e. all triangles of a part instance must be strictly contained inside the box for the part instance to be elected, or loose, in this case, any part instance with a triangle inside the box or intersecting the box will be elected (setOverlapped).

Upon creation a FilterAABBInterface is set to elect all part instances with a strict policy, i.e. all part instances having all triangles strictly inside the box will be elected on a unit box centered on (0,0,0).

The FilterAABBInterface interface is created through the DataSessionInterface.createFilterAABB.

The FilterAABBInterface has the type FilterType.FT_AABB (FilterItemInterface.getFilterType).

The FilterAABBInterface has a depth contribution of 1.

The FilterAABBInterface does not work on moved instances since it is not linked to an InfiniteEngineInterface, moved instances are treated with their original positions.

/** 
 * Sample to illustrate the use of an intersection of 
 * FilterAABBInterface and FilterAttributeInterface.
 */
import {
    AABB, AttributesDictionaryInterface, AttributeInfoInterface, AttributeType, DataSessionInterface,
    WorkingSetInterface,
    FilterAABBInterface, FilterAttributeInterface, GroupOperator, WorkingSetDataRetrieval, WorkingSetBehavior,
} from 'generated_files/documentation/appinfiniteapi';

// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;

// MAKE SURE the attributes "CompletionStatus"
const lAttributeDictionary : AttributesDictionaryInterface = lDataSession.getAttributesDictionary();
const lAttributeInfo : AttributeInfoInterface | undefined = lAttributeDictionary.getAttributeInfo('CompletionStatus');
// make sure the attribute is a string one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_STRING));

// create the resolution chain : 
// create a Working set "unconfigured"
// first create WorkingSetInterface "unconfigured"
// we want to get geometric instances result
// if nothing is set, this working set should include all parts ('unconfigured')
const lConfCtx : WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_OnlyGeometricInstances,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit | WorkingSetBehavior.B_DiscardFiltersIfEmptyBit | WorkingSetBehavior.B_DiscardDependenciesIfEmptyBit
);

// and create the Working set and bind it to the unconfigured WorkingSetInterface
const lConfVisibilityCtx: WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_Nothing,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit | WorkingSetBehavior.B_DiscardFiltersIfEmptyBit
);
lConfVisibilityCtx.insertWorkingSetDependency(0, lConfCtx, GroupOperator.GO_INTERSECTION);

// the AABB to use
const lABB : AABB = new AABB();
lABB.mCenter.x = 3;
lABB.mCenter.y = 3;
lABB.mCenter.z = 3;

lABB.mHalfExtent.x = 10;
lABB.mHalfExtent.y = 10;
lABB.mHalfExtent.z = 10;

// create a Filter Solver
const lFilterSolver : WorkingSetInterface = lDataSession.createWorkingSet(
    WorkingSetDataRetrieval.R_OnlyGeometricInstances,
    WorkingSetBehavior.B_DiscardConfigurationsIfEmptyBit
);
// we want to get geometric instances result
lFilterSolver.setRetrieveDataMode(WorkingSetDataRetrieval.R_OnlyGeometricInstances);
// create a box filter
const lFilterAABB : FilterAABBInterface = lDataSession.createFilterAABB();
// useless, GroupOperator.GO_UNION is the default operator when creating a new filter
// lFilterAABB.setFilterOperator(GroupOperator.GO_UNION);

lFilterAABB.setAABB(lABB);

// create an FilterAttributeInterface
const lFilterAttributes : FilterAttributeInterface = lDataSession.createFilterAttribute();
// completion status to done
lFilterAttributes.setAttributeName('CompletionStatus');
lFilterAttributes.setExactValues(['done']);
// no n/a
lFilterAttributes.setNaValueChecked(false);

// intersection is the way to go since intersection of box and instances that have the field "CompletionStatus"
// to "done"
// only change the operator of the filters except the first
lFilterAttributes.setFilterOperator(GroupOperator.GO_INTERSECTION);

// and add the filters
// push back (-1) the AABB filter
lFilterSolver.insertFilter(-1, lFilterAABB);
// push back (-1) the FilterAttributeInterface, as it is the second one, its operator is used and therefore
// intersection is used
lFilterSolver.insertFilter(-1, lFilterAttributes);

// set the conf context to use => unconfigured for this example
lFilterSolver.insertWorkingSetDependency(0, lConfVisibilityCtx, GroupOperator.GO_UNION);
// and tell the DataSessionInterface to update the modified WorkingSetInterfaces
lDataSession.update();

Please refer to Available Filters for a list of other FilterItemInterfaces.

Metadata/Filters

See

interface FilterAABBInterface {
    addEventListener(pType, pListener, pObject): string;
    addEventListener(pType, pListener): string;
    areSignalsBlocked(): boolean;
    blockSignals(pBlock): void;
    dispose(): void;
    fromJSON(pFilterData): boolean;
    getAABB(pAABBOut): void;
    getDepthContribution(): number;
    getFilterId(): string;
    getFilterOperator(): GroupOperator;
    getFilterType(): FilterType;
    getInfiniteObjectType(): InfiniteObjectType;
    getLastError(): InfiniteError;
    getParentFilter(): FilterSetInterface;
    getParentFilterId(): string;
    hasEventListener(pType, pListener): boolean;
    hasEventListenerById(pId): boolean;
    isDisposed(): boolean;
    isEnabled(): boolean;
    isInverted(): boolean;
    isOverlapped(): boolean;
    removeAllEventListeners(): boolean;
    removeEventListener(pType, pListener, pObject): boolean;
    removeEventListener(pType, pListener): boolean;
    removeEventListenerById(pId): boolean;
    setAABB(pAABB): boolean;
    setEnabled(pEnabled): void;
    setFilterId(pFilterId): void;
    setFilterOperator(pFilterOperator): void;
    setInverted(pInverted): void;
    setOverlapped(pIncludeOverlappingTriangle): void;
    toJSON(pKey?): Object;
}

Hierarchy (view full)

FilterItemInterface
- FilterAABBInterface

Methods

addEventListener

addEventListener(pType, pListener, pObject): string
Adds a listener to an event type.

When an event of the type pType fires, the callback pListener will be called. This function returns a unique string id that may be used in removeEventListenerById to allow simple listener removal. It is possible to add an object that will be included in the callback to avoid creating too many closures. Calling twice addEventListener with the same parameters results in the second call to be ignored, only unique pairs callback / object are allowed, in order to avoid calling multiple times the same thing.
Parameters
- pType: string
  in
  The type of the event pListener will be called upon.
- pListener: tListenerCallback
  in
  The listener function that fires when the given event type occurs.
- pObject: Object
  in
  The optional object the callback will be called with when the given event fires.
Returns string
The id of the inserted callback (actually an UUID).

Inherited from FilterItemInterface.addEventListener
addEventListener(pType, pListener): string
Adds a listener to an event type.

When an event of the type pType fires, the callback pListener will be called. This function returns a unique string id that may be used in removeEventListenerById to allow simple listener removal.
Parameters
- pType: string
  in
  The type of the event pListener will be called upon.
- pListener: tListenerCallback
  in
  The listener function that fires when the given event type occurs.
Returns string
The id of the inserted callback (actually an UUID).

Inherited from FilterItemInterface.addEventListener

areSignalsBlocked

areSignalsBlocked(): boolean
Tells if signals sent by the object are blocked or not.

If signals are blocked, no signal will be emitted nor buffered, such signal will be lost.

Returns boolean
true if signals are blocked.

Inherited from FilterItemInterface.areSignalsBlocked

blockSignals

blockSignals(pBlock): void
Blocks / Unblocks all signals sent by the object.

If signals are blocked, no signal will be emitted nor buffered, such signal will be lost.
Parameters
- pBlock: boolean
  in
  If set to true, all further signals will be silently discarded.
Returns void
Inherited from FilterItemInterface.blockSignals

dispose

dispose(): void
Gets rid of this object.

After this call, this object can no longer be used.

If the object is an InfiniteObjectDispatcherInterface, then the InfiniteObjectDispatcherInterfaceSignal.ObjectDisposed signal is emitted.

Further uses of the object (with the exception of isDisposed, getInfiniteObjectType and application id retrieval) will log a message with LogLevel.LL_UsingDisposedObject.

Returns void
See
Inherited from FilterItemInterface.dispose

fromJSON

fromJSON(pFilterData): boolean

Sets the content of the FilterItemInterface from a former call to toJSON.

Use addEventListener on the event FilterItemInterfaceSignal.FilterDataChanged to know when the FilterItemInterface internal data changed.

{
    "$defs": {
        "all": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "all",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "id"
            ],
            "title": "Filter all definition",
            "type": "object"
        },
        "attribute": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "containsValues": {
                    "description": "Elects all the `part instances` having the attribute whose name set with attribute in their `joined attribute set` that have a value that contains at least one of the values in the given string array",
                    "items": {
                        "type": "string"
                    },
                    "type": "array"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "exactValues": {
                    "description": "Elects all the `part instances` having the attribute whose name set with `attribute` in their `joined attribute set` that have a value exactly included in the given string array.",
                    "items": {
                        "type": "string"
                    },
                    "type": "array"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "na": {
                    "description": "Include `part instances` with the `N/A` value",
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "attribute",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "enabled",
                "operator",
                "inverted",
                "exactValues",
                "containsValues",
                "na",
                "attribute",
                "id"
            ],
            "title": "Filter attribute definition",
            "type": "object"
        },
        "boolean": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "boolean",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "value": {
                    "default": false,
                    "description": "Boolean value of the filter",
                    "example": false,
                    "type": "boolean"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "attribute",
                "value",
                "id"
            ],
            "title": "Filter boolean definition",
            "type": "object"
        },
        "box": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "max": {
                    "description": "Define the coordinates [x,y,z] of the max point of the AABB",
                    "items": {
                        "type": "number"
                    },
                    "maxItems": 3,
                    "minItems": 3,
                    "type": "array"
                },
                "min": {
                    "description": "Define the coordinates [x,y,z] of the min point of the AABB",
                    "items": {
                        "type": "number"
                    },
                    "maxItems": 3,
                    "minItems": 3,
                    "type": "array"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "overlap": {
                    "description": "Specify if AABB test is included or overlap",
                    "example": true,
                    "type": "boolean"
                },
                "precision": {
                    "description": "Numeric precision will be subtracted/added to min/max point of AABB",
                    "type": "number"
                },
                "type": {
                    "const": "box",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "inverted",
                "enabled",
                "min",
                "max",
                "overlap",
                "precision",
                "id"
            ],
            "title": "Filter box definition",
            "type": "object"
        },
        "compound": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "subfilters": {
                    "description": "list of metadata sub filters",
                    "items": {
                        "$ref": "#/$defs/compoundfilters"
                    },
                    "type": "array"
                },
                "type": {
                    "const": "compound",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "subfilters",
                "id"
            ],
            "title": "Filter compound definition",
            "type": "object"
        },
        "compoundfilters": {
            "oneOf": [
                {
                    "$ref": "#/$defs/boolean"
                },
                {
                    "$ref": "#/$defs/hasfield"
                },
                {
                    "$ref": "#/$defs/attribute"
                },
                {
                    "$ref": "#/$defs/range"
                }
            ]
        },
        "diagonal": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "rangeitems": {
                    "description": "List of range item",
                    "items": {
                        "$ref": "#/$defs/rangeitem"
                    },
                    "type": "array"
                },
                "type": {
                    "const": "diagonal",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "rangeitems",
                "id"
            ],
            "title": "Filter diagonal definition",
            "type": "object"
        },
        "filter": {
            "oneOf": [
                {
                    "$ref": "#/$defs/box"
                },
                {
                    "$ref": "#/$defs/all"
                },
                {
                    "$ref": "#/$defs/attribute"
                },
                {
                    "$ref": "#/$defs/boolean"
                },
                {
                    "$ref": "#/$defs/literal"
                },
                {
                    "$ref": "#/$defs/compound"
                },
                {
                    "$ref": "#/$defs/diagonal"
                },
                {
                    "$ref": "#/$defs/hasfield"
                },
                {
                    "$ref": "#/$defs/partinstanceidlist"
                },
                {
                    "$ref": "#/$defs/range"
                },
                {
                    "$ref": "#/$defs/filterset"
                }
            ]
        },
        "filterset": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "subfilters": {
                    "description": "List of sub filters",
                    "items": {
                        "oneOf": [
                            {
                                "$ref": "#/$defs/box"
                            },
                            {
                                "$ref": "#/$defs/all"
                            },
                            {
                                "$ref": "#/$defs/attribute"
                            },
                            {
                                "$ref": "#/$defs/boolean"
                            },
                            {
                                "$ref": "#/$defs/literal"
                            },
                            {
                                "$ref": "#/$defs/compound"
                            },
                            {
                                "$ref": "#/$defs/diagonal"
                            },
                            {
                                "$ref": "#/$defs/hasfield"
                            },
                            {
                                "$ref": "#/$defs/partinstanceidlist"
                            },
                            {
                                "$ref": "#/$defs/range"
                            },
                            {
                                "$ref": "#/$defs/filterset"
                            }
                        ]
                    },
                    "type": "array"
                },
                "type": {
                    "const": "set",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "enabled",
                "operator",
                "inverted",
                "subfilters",
                "id"
            ],
            "title": "Filter set definition",
            "type": "object"
        },
        "hasfield": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "hasfield",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "attribute",
                "id"
            ],
            "title": "Filter Has field definition",
            "type": "object"
        },
        "literal": {
            "additionalProperties": false,
            "properties": {
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "query": {
                    "description": "Sets the query string in the 3djuump infinite literal and search query language",
                    "example": ":PartNumber=='bolt'",
                    "type": "string"
                },
                "type": {
                    "const": "literal",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "query",
                "id"
            ],
            "title": "Filter literal definition",
            "type": "object"
        },
        "partinstanceidlist": {
            "additionalProperties": false,
            "properties": {
                "buildid": {
                    "description": "Id of the build use to create the part list instance",
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "list": {
                    "description": "List of part instance ids",
                    "items": {
                        "type": "number"
                    },
                    "type": "array"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "type": {
                    "const": "partinstanceidlist",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "buildid",
                "list",
                "id"
            ],
            "title": "Filter Part instance list definition",
            "type": "object"
        },
        "range": {
            "additionalProperties": false,
            "properties": {
                "attribute": {
                    "description": "Name of the attribute to filter with",
                    "example": "PartNumber",
                    "minLength": 0,
                    "type": "string"
                },
                "enabled": {
                    "default": true,
                    "description": "If disabled, this filter is completely ignored during all the computations",
                    "example": true,
                    "type": "boolean"
                },
                "id": {
                    "description": "an object id : only ascii non control and non blank characters",
                    "example": "123e4567e89b12d3a456426614174000",
                    "maxLength": 64,
                    "pattern": "^[\\x21-\\x7E]{1,64}$",
                    "type": "string"
                },
                "inverted": {
                    "description": "When 'inverted', a filter elects all the `part instances` that would not be selected if it was not inverted.",
                    "example": true,
                    "type": "boolean"
                },
                "operator": {
                    "default": "and",
                    "description": "Operator to apply with this filter and its closest enabled predecessor in its parent container.",
                    "enum": [
                        "or",
                        "and",
                        "minus"
                    ],
                    "example": "or",
                    "type": "string"
                },
                "rangeitems": {
                    "description": "List of range item",
                    "items": {
                        "$ref": "#/$defs/rangeitem"
                    },
                    "type": "array"
                },
                "type": {
                    "const": "range",
                    "description": "Type of the filter",
                    "type": "string"
                },
                "version": {
                    "description": "Define the version of the object",
                    "example": 1,
                    "type": "integer"
                }
            },
            "required": [
                "type",
                "operator",
                "enabled",
                "inverted",
                "attribute",
                "rangeitems",
                "id"
            ],
            "title": "Filter range definition",
            "type": "object"
        },
        "rangeitem": {
            "additionalProperties": false,
            "properties": {
                "includedLower": {
                    "description": "Sets if the lower bound value should be included or excluded",
                    "type": "boolean"
                },
                "includedUpper": {
                    "description": "Sets if the upper bound value should be included or excluded",
                    "type": "boolean"
                },
                "lower": {
                    "description": "Lower bound of the range item",
                    "type": "number"
                },
                "upper": {
                    "description": "Upper bound of the range item",
                    "type": "number"
                }
            },
            "required": [
                "includedLower",
                "includedUpper"
            ],
            "title": "Range item definition",
            "type": "object"
        }
    },
    "$ref": "#/$defs/filter",
    "$schema": "https://json-schema.org/draft-07/schema#"
}

This schema may evolve in the future.

Parameters

pFilterData: string | Object
in
Internal FilterItemInterface data to set.

Returns boolean

true if the data is set.

See

toJSON

getAABB

getAABB(pAABBOut): void
Gets the axis align bounding box parameters.

pAABBOut will be set with the content of the box.
Parameters
- pAABBOut: AABB
  out
  Upon completion, stores the current AABB of the FilterAABBInterface.
Returns void

getDepthContribution

getDepthContribution(): number
Gets the depth contribution of the FilterItemInterface.

This value is usually one.

Returns number
The depth contribution of the FilterItemInterface.

Inherited from FilterItemInterface.getDepthContribution

getFilterId

getFilterId(): string
Gets the identifier of the FilterItemInterface.

Returns string
The identifier of the FilterItemInterface.

Inherited from FilterItemInterface.getFilterId

getFilterOperator

getFilterOperator(): GroupOperator
Gets the operator to apply with this FilterItemInterface and its closest enabled predecessor in its parent container.

The FilterItemInterface operator of the first enabled FilterItemInterface in a parent list (WorkingSetInterface, FilterSetInterface, FilterCompoundInterface) is always ignored, but a warning is outputted in the console when the GroupOperator is different that GroupOperator.GO_UNION.

A FilterItemInterface has the GroupOperator.GO_UNION operator by default.

Returns GroupOperator
The operator to combine this FilterItemInterface and its first enabled predecessor.

See
GroupOperator

Inherited from FilterItemInterface.getFilterOperator

getFilterType

getFilterType(): FilterType
Gets the type of the FilterItemInterface.

Returns FilterType
The FilterItemInterface type.

See
FilterType

Inherited from FilterItemInterface.getFilterType

getInfiniteObjectType

getInfiniteObjectType(): InfiniteObjectType
Tells the type of the given interface.

Returns InfiniteObjectType
The type of the given interface.

Inherited from FilterItemInterface.getInfiniteObjectType

getLastError

getLastError(): InfiniteError
Gets the last error returned after the update of the WorkingSetInterface this filter belongs to.

This helps get the filter that is in error if the WorkingSetInterface is in error.

The error message is updated If the containing WorkingSetInterface is modified and DataSessionInterface.update is called.

Returns InfiniteError
An InfiniteError containing the last error if any, or undefined if no error occurred.

Inherited from FilterItemInterface.getLastError

getParentFilter

getParentFilter(): FilterSetInterface
Gets the parent container that contains this FilterItemInterface (getFilterId()).

Such a container may be a FilterSetInterface or a FilterCompoundInterface. Returns an empty string if the FilterItemInterface is not included in a parent container or directly inside a WorkingSetInterface.

Returns FilterSetInterface
The parent container if any.

Inherited from FilterItemInterface.getParentFilter

getParentFilterId

getParentFilterId(): string
Gets the identifier of the parent container that contains this FilterItemInterface (getFilterId()).

Such a container may be a FilterSetInterface or a FilterCompoundInterface. Returns an empty string if the FilterItemInterface is not included in a parent container or directly inside a WorkingSetInterface.

Returns string
The identifier of the parent container.

Inherited from FilterItemInterface.getParentFilterId

hasEventListener

hasEventListener(pType, pListener): boolean
Tells if the EventDispatcher has such a callback registered for the given event type.
Parameters
- pType: string
  in
  The type of the event to test.
- pListener: tListenerCallback
  in
  The listener function that gets tested.
Returns boolean
true if such a listener is installed for the given type of event.

Inherited from FilterItemInterface.hasEventListener

hasEventListenerById

hasEventListenerById(pId): boolean
Tells if the EventDispatcher has such a callback registered for the given callback id.
Parameters
- pId: string
  in
  The id of the callback to test.
Returns boolean
true if such a listener is installed for the given callback id.

Inherited from FilterItemInterface.hasEventListenerById

isDisposed

isDisposed(): boolean
Tells if this object has been gotten rid off.

Returns boolean
true if dispose has been called on this object.

Inherited from FilterItemInterface.isDisposed

isEnabled

isEnabled(): boolean
Tells if the FilterItemInterface is enabled.

If disabled, this FilterItemInterface is completely ignored during all the computations (the behavior is the same as if it had not been created).

A FilterItemInterface is enabled by default.

Returns boolean
true if the FilterItemInterface is enabled.

Inherited from FilterItemInterface.isEnabled

isInverted

isInverted(): boolean
Tells if the FilterItemInterface is "inverted".

When "inverted", a FilterItemInterface elects all the part instances that were not selected if it was not inverted.

A FilterItemInterface is not "inverted" by default.

Returns boolean
true if such a FilterItemInterface is "inverted".

Inherited from FilterItemInterface.isInverted

isOverlapped

isOverlapped(): boolean
Tells about the loose/strict including policy.

If overlapped (loose), any part instance with at least one triangle overlapping the box will be elected, else any part instance should have all its triangles strictly included inside the box to be elected (strict).

Upon creation, the FilterAABBInterface is set to include all part instances strictly inside the box (false as default).

Returns boolean
true if the FilterAABBInterface including policy is loose.

removeAllEventListeners

removeAllEventListeners(): boolean
Removes all the event listeners.

Returns boolean
true if all the callbacks were removed else false.

Inherited from FilterItemInterface.removeAllEventListeners

removeEventListener

removeEventListener(pType, pListener, pObject): boolean
Removes a listener from an event type.

If no such listener is found, then the function returns false and does nothing. You must use the exact parameters that were used in addEventListener to actually remove the listener.
Parameters
- pType: string
  in
  The type of the listener that gets removed.
- pListener: tListenerCallback
  The listener function that gets removed.
- pObject: Object
  The listener object that was used when addEventListener was called.
Returns boolean
true if the callback was removed else false.

Inherited from FilterItemInterface.removeEventListener
removeEventListener(pType, pListener): boolean
Removes a listener from an event type.

If no such listener is found, then the function returns false and does nothing. You must use the exact parameters that were used in addEventListener to actually remove the listener.
Parameters
- pType: string
  in
  The type of the listener that gets removed.
- pListener: tListenerCallback
  The listener function that gets removed.
Returns boolean
true if the callback was removed else false.

Inherited from FilterItemInterface.removeEventListener

removeEventListenerById

removeEventListenerById(pId): boolean
Removes a listener by its id.

If no such listener is found, then the function returns false and does nothing. You must use the return value of addEventListener to actually remove the listener.
Parameters
- pId: string
  in
  The id returned by the call to addEventListener that you want to remove.
Returns boolean
true if the callback was removed else false.

Inherited from FilterItemInterface.removeEventListenerById

setAABB

setAABB(pAABB): boolean
Sets the axis align bounding box.

The FilterAABBInterface stores a copy of the data, the caller may change the box later without worrying about the FilterAABBInterface being modified.

Does nothing if the AABB is left unchanged.

Use addEventListener on the event FilterItemInterfaceSignal.FilterDataChanged to know when the FilterAABBInterface data changed.

A FilterAABBInterface has a unit box centered on (0,0,0) by default.

Returns true if pAABB is set.
Parameters
- pAABB: AABB
  in
  The axis aligned box to set.
Returns boolean
true if the AABB is set.

setEnabled

setEnabled(pEnabled): void
Sets the FilterItemInterface enabled/disabled status.

If disabled, this FilterItemInterface is completely ignored during all the computations (the behavior is the same as if it had not been created). Use addEventListener on the event FilterItemInterfaceSignal.FilterEnabledChanged to know when the FilterItemInterface has changed its enabled status. Modifying a disabled FilterItemInterface will not trigger any change in the containing FilterSetInterface / WorkingSetInterface.

A FilterItemInterface is enabled by default.
Parameters
- pEnabled: boolean
  in
  If true, the given FilterItemInterface is enabled.
Returns void
Inherited from FilterItemInterface.setEnabled

setFilterId

setFilterId(pFilterId): void
Sets the identifier of the FilterItemInterface.

Make sure the id is unique across the application.
Parameters
- pFilterId: string
  in
  The new identifier of the FilterItemInterface.
Returns void
Inherited from FilterItemInterface.setFilterId

setFilterOperator

setFilterOperator(pFilterOperator): void
Sets the operator to apply with this FilterItemInterface and its closest enabled predecessor in its parent container.

The FilterItemInterface operator of the first enabled FilterItemInterface in a parent list (WorkingSetInterface, FilterSetInterface, FilterCompoundInterface) is always ignored, but a warning is outputted in the console when the GroupOperator is different that GroupOperator.GO_UNION. Use addEventListener on the event FilterItemInterfaceSignal.FilterInvertedChanged to know when the FilterItemInterface operator changed.

A FilterItemInterface has the GroupOperator.GO_UNION operator by default.
Parameters
- pFilterOperator: GroupOperator
  in
  The operator to combine this FilterItemInterface and its first enabled predecessor.
Returns void
See
GroupOperator

Inherited from FilterItemInterface.setFilterOperator

setInverted

setInverted(pInverted): void
Sets the "inverted" status of the FilterItemInterface.

When "inverted", a FilterItemInterface elects all the part instances that were not selected if it was not inverted. Use addEventListener on the event FilterItemInterfaceSignal.FilterInvertedChanged to know when the FilterItemInterface has changed its "inverted" status.

A FilterItemInterface is not "inverted" by default.
Parameters
- pInverted: boolean
  in
  If true, such a FilterItemInterface will be "inverted".
Returns void
Inherited from FilterItemInterface.setInverted

setOverlapped

setOverlapped(pIncludeOverlappingTriangle): void
Sets the loose/strict including policy.

If overlapped (loose), any part instance with at least one triangle overlapping the box will be elected, else any part instance should have all its triangles strictly included inside the box to be elected (strict).

Upon creation, the FilterAABBInterface is set to include all part instances strictly inside the box (false as default).

Use addEventListener on the event FilterItemInterfaceSignal.FilterDataChanged to know when the FilterAABBInterface data changed.
Parameters
- pIncludeOverlappingTriangle: boolean
  in
  If set, any part instance with at least one triangle overlapping the box will be elected.
Returns void

toJSON

toJSON(pKey?): Object
Gets a deep copy of the internal data of the FilterItemInterface.

Please refer to JSON.stringify.
Parameters
- Optional pKey: any
  in
  Unused.
Returns Object
The internal FilterItemInterface data.

See
fromJSON

Inherited from FilterItemInterface.toJSON

Interface FilterAABBInterface

See

Hierarchy (view full)

Index

Methods

Methods

addEventListener

Parameters

Returns string

Parameters

Returns string

areSignalsBlocked

Returns boolean

blockSignals

Parameters

Returns void

dispose

Returns void

See

fromJSON

Parameters

Returns boolean

See

getAABB

Parameters

Returns void

getDepthContribution

Returns number

getFilterId

Returns string

getFilterOperator

Returns GroupOperator

See

getFilterType

Returns FilterType

See

getInfiniteObjectType

Returns InfiniteObjectType

getLastError

Returns InfiniteError

getParentFilter

Returns FilterSetInterface

getParentFilterId

Returns string

hasEventListener

Parameters

Returns boolean

hasEventListenerById

Parameters

Returns boolean

isDisposed

Returns boolean

isEnabled

Returns boolean

isInverted

Returns boolean

isOverlapped

Returns boolean

removeAllEventListeners

Returns boolean

removeEventListener

Parameters

Returns boolean

Parameters

Returns boolean

removeEventListenerById

Parameters

Returns boolean

setAABB

Parameters

Returns boolean

setEnabled

Parameters

Returns void

setFilterId

Parameters

Returns void

setFilterOperator

Parameters

Returns void