LocationAwareness doesn't detect other symbolic spaces in building

[JohanTran02]

Hi,

I'm developing on a project for indoor positioning and currently work on geofencing. I got OpenHPS exercises to familiarize with the framework and the current exercise I'm working on is:

Emit the event of entering and exiting a space

However when I print the values of the spaces it only detects the building Pleinlaan 9 as a SymbolicSpace. What I want to achieve is to detect the different spaces inside the building and tried to use the geographical coordinates of the top left corner of Pleinlaan 9 as a reference point and converted the recieved Absolute3DPosition into a GeographicalPosition in this.watchPosition().

Dependencies for the project and dataset;

"dependencies": {
    "@openhps/core": "^1.0.3",
    "@openhps/csv": "^0.1.11",
    "@openhps/fingerprinting": "^0.1.9",
    "@openhps/geospatial": "^0.1.30",
    "@openhps/rf": "^1.0.4",
    "reflect-metadata": "^0.2.2"
  },
  "devDependencies": {
    "@types/chai": "^5.2.1",
    "@types/mocha": "^10.0.10",
    "@types/node": "^22.13.13",
    "@typescript-eslint/eslint-plugin": "^8.28.0",
    "@typescript-eslint/parser": "^8.28.0",
    "chai": "^4.5.0",
    "eslint": "^8.57.1",
    "eslint-config-prettier": "^10.1.1",
    "eslint-plugin-deprecation": "^3.0.0",
    "eslint-plugin-import": "^2.31.0",
    "eslint-plugin-jsdoc": "^50.6.9",
    "eslint-plugin-prettier": "^5.2.5",
    "mocha": "^11.1.0",
    "npm-run-all": "^4.1.5",
    "prettier": "^3.5.3",
    "ts-node": "^10.9.2",
    "typescript": "^5.8.2"
  }

protected async loadSpaces(): Promise<void> {
        const spaceService: SymbolicSpaceService<SymbolicSpace<AbsolutePosition>> =
            this.model.findDataService(SymbolicSpace);

        const building = new Building('Pleinlaan 9').setBounds({
            topLeft: new GeographicalPosition(50.820372852678126, 4.3922486526198385),
            width: 46.275,
            length: 37.27,
            height: 50, // Height of the building
            rotation: -34.04,
        });

        let floor = new Floor();
        await spaceService.insertObject(building);

        // For each GeoJSON feature in the JSON file ...
        await GEOJSON_FEATURES.features.forEach(async (feature: any) => {
            const space = SymbolicSpace.fromGeoJSON(feature);
            if (space instanceof Floor) {
                space.setBuilding(building).setFloorNumber(3);
                floor = space.clone();
            }

            if (space instanceof CellSpace) {
                space.setFloor(floor).setBounds([
                    ...space.getBounds().map((coords) => {
                        const tempCoords = coords.clone() as GeographicalPosition;
                        return new GeographicalPosition(tempCoords.latitude, tempCoords.longitude, tempCoords.altitude);
                    }),
                ]);
            }

            // Store the space in memory
            await spaceService.insertObject(space);
        });
    }

    /**
     * Listen for position changes
     * @param {number} interval How often to check for updates if no new information arrives automatically
     */
    listen(interval = 1000): void {
        const spaceService: SymbolicSpaceService<SymbolicSpace<AbsolutePosition>> =
            this.model.findDataService(SymbolicSpace);
        // Variable storing the last known space of a user (lets assume we only track one user)
        let myCurrentSpace: SymbolicSpace<AbsolutePosition> = undefined;

        // https://openhps.org/docs/core/classes/locationbasedservice
        this.watchPosition(
            'me',
            (position: AbsolutePosition, err?: Error) => {
                if (err) {
                    return;
                }
                // Emit move of a position
                this.emit('move', position);

                const buildingTopLeft = new GeographicalPosition(50.820372852678126, 4.3922486526198385);
                const refVector: Vector3 = buildingTopLeft.toVector3(LengthUnit.METER).clone(); // Convert to meters

                // Convert the position to a floor position in the building
                const floorVector = position.toVector3(LengthUnit.METER).clone() as Vector3;

                const localVector = refVector.subVectors(refVector, floorVector).clone();

                const localPosition = new Absolute3DPosition(localVector.x, localVector.y, localVector.z);

                const finalPosition = new GeographicalPosition().fromVector(
                    localPosition.toVector3(),
                    LengthUnit.METER,
                );
                finalPosition.altitude = 0;

                // const floorPosition = position.clone() as Absolute3DPosition;
                // floorPosition.z += 83 + 9; // Floor height above sea level
                // floorPosition.z += 9; // Floor height above sea level
                /**
                 * QUESTION 2: Emit the event of entering and exiting a space
                 * This event should only trigger when you enter a new space.
                 * The 'enterspace' event should only trigger when you enter a new space
                 * The 'exitspace' event should only trigger when you leave a space
                 *
                 * TIP: Entering a space from another space means you first exit your previous
                 *      space and then enter a new space.
                 * TIP: Not every position has an accompanying space
                 * TIP: Use `spaceService` defined at the top of this listen function
                 * TIP: Use `myCurrentSpace` defined at the top of this listen function
                 * @see {@link https://openhps.org/docs/geospatial/classes/symbolicspaceservice}
                 */
                spaceService.findSymbolicSpaces(finalPosition).then((spaces) => {
                    const space = spaces.length > 0 ? spaces[0][0] : undefined;
                    if (!myCurrentSpace && space) {
                        // Entering the first space
                        this.emit('enterspace', space, position);
                    } else if (myCurrentSpace && !space) {
                        // Leaving to an unknown space
                        this.emit('exitspace', myCurrentSpace, position);
                    } else if (myCurrentSpace && space && myCurrentSpace.uid !== space.uid) {
                        // Entering a space and leaving the previous space
                        this.emit('exitspace', myCurrentSpace, position);
                        this.emit('enterspace', space, position);
                    }
                    myCurrentSpace = space;
                });
            },
            {
                interval,
                forceUpdate: true,
            },
        );
    }

[JohanTran02]

Solved it!

The altitude affected the bounds for the symbolic spaces so I opted to only using lat and long coordinates.

        await GEOJSON_FEATURES.features.forEach(async (feature: any) => {
            const space = SymbolicSpace.fromGeoJSON(feature);
            if (space instanceof Floor) {
                space.setBuilding(building).setFloorNumber(3);
                floor = space.clone();
            }

            if (space instanceof CellSpace) {
                space.setFloor(floor).setBounds([
                    ...space.getBounds().map((coords) => {
                        const tempCoords = coords.clone() as GeographicalPosition;
                        return new GeographicalPosition(tempCoords.latitude, tempCoords.longitude);
                    }),
                ]);
            }

            // Store the space in memory
            await spaceService.insertObject(space);
        });