Import region metadata from TFRecords

src/common/htmlFileReader.test.ts

@@ -111,8 +111,7 @@ describe("Html File Reader", () => {
     });
 
     describe("Download asset binaries array", () => {
-        it("Downloads a byte array from the asset path", async () => {
-            const asset = AssetService.createAssetFromFilePath("https://server.com/image.jpg");
+        beforeEach(() => {
             axios.get = jest.fn((url, config) => {
                 return Promise.resolve<AxiosResponse>({
                     config,
@@ -122,35 +121,59 @@ describe("Html File Reader", () => {
                     data: [1, 2, 3],
                 });
             });
+        });
 
+        it("Downloads a byte array from the asset path", async () => {
+            const asset = AssetService.createAssetFromFilePath("https://server.com/image.jpg");
             const result = await HtmlFileReader.getAssetArray(asset);
             expect(result).not.toBeNull();
             expect(result).toBeInstanceOf(Uint8Array);
             expect(axios.get).toBeCalledWith(asset.path, { responseType: "blob" });
         });
+
+        it("Test non valid asset type", async () => {
+            const imageAsset = AssetService.createAssetFromFilePath("https://server.com/image.notsupported");
+            try {
+                const result = await HtmlFileReader.readAssetAttributes(imageAsset);
+            } catch (error) {
+                expect(error).toEqual(new Error("Asset not supported"));
+            }
+        });
     });
 
-    it("Test non valid asset type", async () => {
-        axios.get = jest.fn((url, config) => {
-            return Promise.resolve<AxiosResponse>({
-                config,
-                headers: null,
-                status: 200,
-                statusText: "OK",
-                data: [1, 2, 3],
+    describe("Test TFRecords", () => {
+        it("Loads attributes for a tfrecord asset", async () => {
+            const expected = {
+                width: 1920,
+                height: 1080,
+            };
+
+            axios.get = jest.fn((url, config) => {
+                const builder = new TFRecordsBuilder();
+                builder.addFeature("image/height", FeatureType.Int64, expected.height);
+                builder.addFeature("image/width", FeatureType.Int64, expected.width);
+                const buffer = builder.build();
+                const tfrecords = TFRecordsBuilder.buildTFRecords([buffer]);
+
+                return Promise.resolve<AxiosResponse>({
+                    config,
+                    headers: null,
+                    status: 200,
+                    statusText: "OK",
+                    data: tfrecords,
+                });
             });
-        });
 
-        const imageAsset = AssetService.createAssetFromFilePath("https://server.com/image.notsupported");
-        try {
+            const imageAsset = AssetService.createAssetFromFilePath("https://server.com/image.tfrecord");
             const result = await HtmlFileReader.readAssetAttributes(imageAsset);
-        } catch (error) {
-            expect(error).toEqual(new Error("Asset not supported"));
-        }
+
+            expect(result.width).toEqual(expected.width);
+            expect(result.height).toEqual(expected.height);
+        });
     });
 
     describe("Test TFRecords", () => {
-        it("Loads attributes for a tfrecord asset", async () => {
+        it("Loads attributes for an tfrecord asset", async () => {
             const expected = {
                 width: 1920,
                 height: 1080,

src/common/mockFactory.ts

@@ -50,18 +50,21 @@ export default class MockFactory {
      * Creates fake IAsset
      * @param name Name of asset
      * @param assetState State of asset
+     * @param path Path of asset
+     * @param assetType Type of asset
      */
     public static createTestAsset(
         name: string,
         assetState: AssetState = AssetState.NotVisited,
-        path: string = `C:\\Desktop\\asset${name}.jpg`): IAsset {
+        path: string = `C:\\Desktop\\asset${name}.jpg`,
+        assetType: AssetType = AssetType.Image): IAsset {
         return {
             id: `asset-${name}`,
             format: "jpg",
             name: `Asset ${name}.jpg`,
             path: `${path}`,
             state: assetState,
-            type: AssetType.Image,
+            type: assetType,
             size: {
                 width: 800,
                 height: 600,

src/models/applicationState.ts

@@ -333,3 +333,13 @@ export interface ISecurityToken {
     name: string;
     key: string;
 }
+
+export interface ITFRecordMetadata {
+    width: number;
+    height: number;
+    xminArray: number[];
+    yminArray: number[];
+    xmaxArray: number[];
+    ymaxArray: number[];
+    textArray: string[];
+}

src/providers/export/tensorFlowRecords.ts

@@ -183,10 +183,12 @@ export class TFRecordsJsonExportProvider extends ExportProvider<ITFRecordsJsonEx
 
                                         imageInfo.text.push(tag.name);
                                         imageInfo.label.push(index);
-                                        imageInfo.xmin.push(region.boundingBox.left);
-                                        imageInfo.ymin.push(region.boundingBox.top);
-                                        imageInfo.xmax.push(region.boundingBox.left + region.boundingBox.width);
-                                        imageInfo.ymax.push(region.boundingBox.top + region.boundingBox.height);
+                                        imageInfo.xmin.push(region.boundingBox.left / imageInfo.width);
+                                        imageInfo.ymin.push(region.boundingBox.top / imageInfo.height);
+                                        imageInfo.xmax.push((region.boundingBox.left + region.boundingBox.width)
+                                            / imageInfo.width);
+                                        imageInfo.ymax.push((region.boundingBox.top + region.boundingBox.height)
+                                            / imageInfo.height);
                                         imageInfo.difficult.push(0);
                                         imageInfo.truncated.push(0);
                                         imageInfo.view.push("Unspecified");

src/providers/export/tensorFlowRecords/tensorFlowReader.test.ts

@@ -94,5 +94,35 @@ describe("TFRecords Reader/Builder Integration test", () => {
             expect(floatValue).toEqual(12345.0);
             expect(binaryValue).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
         });
+
+        it("Check feature array value on a single TFRecord", async () => {
+            builder.addArrayFeature("feature/1", FeatureType.Int64, [1, 2]);
+            builder.addArrayFeature("feature/2", FeatureType.Float, [1.0, 2.0]);
+            builder.addArrayFeature("feature/3", FeatureType.String, ["1", "2"]);
+            builder.addArrayFeature("feature/4", FeatureType.Binary, [new Uint8Array([1]), new Uint8Array([2])]);
+
+            const buffer = builder.build();
+            const tfrecords = TFRecordsBuilder.buildTFRecords([buffer]);
+
+            const reader = new TFRecordsReader(tfrecords);
+            const intValueArray = reader.getArrayFeature(0, "feature/1", FeatureType.Int64) as number[];
+            const floatValueArray = reader.getArrayFeature(0, "feature/2", FeatureType.Float) as number[];
+            const stringValueArray = reader.getArrayFeature(0, "feature/3", FeatureType.String) as string[];
+            const binaryValueArray = reader.getArrayFeature(0, "feature/4", FeatureType.Binary) as Uint8Array[];
+
+            expect(intValueArray.length).toEqual(2);
+            expect(stringValueArray.length).toEqual(2);
+            expect(floatValueArray.length).toEqual(2);
+            expect(binaryValueArray.length).toEqual(2);
+
+            expect(intValueArray[0]).toEqual(1);
+            expect(intValueArray[1]).toEqual(2);
+            expect(floatValueArray[0]).toEqual(1.0);
+            expect(floatValueArray[1]).toEqual(2.0);
+            expect(stringValueArray[0]).toEqual("1");
+            expect(stringValueArray[1]).toEqual("2");
+            expect(binaryValueArray[0]).toEqual(new Uint8Array([1]));
+            expect(binaryValueArray[1]).toEqual(new Uint8Array([2]));
+        });
     });
 });

src/providers/export/tensorFlowRecords/tensorFlowReader.ts

@@ -67,7 +67,7 @@ export class TFRecordsReader {
     /**
      * @recordPos - Record Position
      * @key - Feature Key
-     * @type - Feature Typeq
+     * @type - Feature Type
      * @description - Get a Int64 | Float | String | Binary value
      */
     public getFeature(recordPos: number, key: string, type: FeatureType): string | number | Uint8Array {
@@ -85,4 +85,26 @@ export class TFRecordsReader {
                 return feature.getFloatList().array[0][0];
         }
     }
+
+    /**
+     * @recordPos - Record Position
+     * @key - Feature Key
+     * @type - Feature Type
+     * @description - Get an array of Int64 | Float | String | Binary value
+     */
+    public getArrayFeature(recordPos: number, key: string, type: FeatureType): string[] | number[] | Uint8Array[] {
+        const message = this.imageMessages[recordPos];
+        const feature = message.getContext().getFeatureMap().get(key);
+
+        switch (type) {
+            case FeatureType.String:
+                return feature.getBytesList().array[0].map((buffer) => textDecode(buffer));
+            case FeatureType.Binary:
+                return feature.getBytesList().array[0];
+            case FeatureType.Int64:
+                return feature.getInt64List().array[0];
+            case FeatureType.Float:
+                return feature.getFloatList().array[0];
+        }
+    }
 }

src/react/components/common/assetPreview/imageAsset.tsx

@@ -1,16 +1,10 @@
 import React from "react";
 import { IAssetProps } from "./assetPreview";
 
-/**
- * ImageAsset component properites
- */
-export interface IImageProps extends IAssetProps, React.ClassAttributes<ImageAsset> {
-}
-
 /**
  * ImageAsset component used to render all image assets
  */
-export class ImageAsset extends React.Component<IImageProps> {
+export class ImageAsset extends React.Component<IAssetProps> {
     private image: React.RefObject<HTMLImageElement> = React.createRef();
 
     public render() {