@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/lds/iso19794/faceImageInfo.ts

@@ -0,0 +1,948 @@
+import { Gender } from '../../data/gender';
+import { ByteArrayOutputStream } from '../../java/byteArrayOutputStream';
+import { DataInputStream } from '../../java/dataInputStream';
+import { DataOutputStream } from '../../java/dataOutputStream';
+import { InputStream } from '../../java/inputStream';
+import { OutputStream } from '../../java/outputStream';
+import { AbstractImageInfo } from '../abstractImageInfo';
+import { Buffer } from 'buffer';
+
+/**
+ * Feature points as described in Section 5.6.3 of ISO/IEC FCD 19794-5.
+ */
+export class FeaturePoint {
+  private type: number;
+  private majorCode: number;
+  private minorCode: number;
+  private x: number;
+  private y: number;
+
+  /**
+   * Constructs a new feature point.
+   *
+   * @param type feature point type
+   * @param majorCode major code
+   * @param minorCode minor code
+   * @param x X-coordinate
+   * @param y Y-coordinate
+   */
+  constructor(type: number, code: number, x: number, y: number) {
+    this.type = type;
+    this.majorCode = (code & 0xf0) >> 4;
+    this.minorCode = code & 0x0f;
+    this.x = x;
+    this.y = y;
+  }
+
+  /**
+   * Returns the major code of this point.
+   *
+   * @return major code
+   */
+  public getMajorCode(): number {
+    return this.majorCode;
+  }
+
+  /**
+   * Returns the minor code of this point.
+   *
+   * @return minor code
+   */
+  public getMinorCode(): number {
+    return this.minorCode;
+  }
+
+  /**
+   * Returns the type of this point.
+   *
+   * @return type
+   */
+  public getType(): number {
+    return this.type;
+  }
+
+  /**
+   * Returns the X-coordinate of this point.
+   *
+   * @return X-coordinate
+   */
+  public getX(): number {
+    return this.x;
+  }
+
+  /**
+   * Returns the Y-coordinate of this point.
+   *
+   * @return Y-coordinate
+   */
+  public getY(): number {
+    return this.y;
+  }
+}
+
+// /* These correspond to values in Table 4 in 5.5.4 in ISO/IEC 19794-5:2005(E). */
+// public static EYE_COLOR_UNSPECIFIED = 0x00;
+// public static EYE_COLOR_BLACK = 0x01;
+// public static EYE_COLOR_BLUE = 0x02;
+// public static EYE_COLOR_BROWN = 0x03;
+// public static EYE_COLOR_GRAY = 0x04;
+// public static EYE_COLOR_GREEN = 0x05;
+// public static EYE_COLOR_MULTI_COLORED = 0x06;
+// public static EYE_COLOR_PINK = 0x07;
+// public static EYE_COLOR_UNKNOWN = 0xFF;
+/** Eye color code based on Section 5.5.4 of ISO 19794-5. */
+export class EyeColor {
+  public static UNSPECIFIED = new EyeColor(0x00);
+  public static BLACK = new EyeColor(0x01);
+  public static BLUE = new EyeColor(0x02);
+  public static BROWN = new EyeColor(0x03);
+  public static GRAY = new EyeColor(0x04);
+  public static GREEN = new EyeColor(0x05);
+  public static MULTI_COLORED = new EyeColor(0x06);
+  public static PINK = new EyeColor(0x07);
+  public static UNKNOWN = new EyeColor(0xff);
+
+  private code: number;
+
+  /**
+   * Creates an eye color.
+   *
+   * @param code the ISO19794-5 integer code for the color
+   */
+  constructor(code: number) {
+    this.code = code;
+  }
+
+  /**
+   * Returns the integer code to use in ISO19794-5 encoding for this color.
+   *
+   * @return the integer code
+   */
+  public toInt(): number {
+    return this.code;
+  }
+
+  /**
+   * Returns an eye color value for the given code.
+   *
+   * @param i the integer code for a color
+   *
+   * @return the color value
+   */
+  static toEyeColor(i: number): EyeColor {
+    for (const c of EyeColor.values()) {
+      if (c.toInt() === i) {
+        return c;
+      }
+    }
+    return EyeColor.UNKNOWN;
+  }
+
+  static values() {
+    return [
+      EyeColor.UNSPECIFIED,
+      EyeColor.BLACK,
+      EyeColor.BLUE,
+      EyeColor.BROWN,
+      EyeColor.GRAY,
+      EyeColor.GREEN,
+      EyeColor.MULTI_COLORED,
+      EyeColor.PINK,
+      EyeColor.UNKNOWN,
+    ];
+  }
+}
+
+// public static HAIR_COLOR_UNSPECIFIED = 0x00;
+// public static HAIR_COLOR_BALD = 0x01;
+// public static HAIR_COLOR_BLACK = 0x02;
+// public static HAIR_COLOR_BLONDE = 0x03;
+// public static HAIR_COLOR_BROWN = 0x04;
+// public static HAIR_COLOR_GRAY = 0x05;
+// public static HAIR_COLOR_WHITE = 0x06;
+// public static HAIR_COLOR_RED = 0x07;
+// public static HAIR_COLOR_GREEN = 0x08;
+// public static HAIR_COLOR_BLUE = 0x09;
+// public static HAIR_COLOR_UNKNOWN = 0xFF;
+/** Hair color code based on Section 5.5.5 of ISO 19794-5. */
+export class HairColor {
+  public static UNSPECIFIED = new HairColor(0x00);
+  public static BALD = new HairColor(0x01);
+  public static BLACK = new HairColor(0x02);
+  public static BLONDE = new HairColor(0x03);
+  public static BROWN = new HairColor(0x04);
+  public static GRAY = new HairColor(0x05);
+  public static WHITE = new HairColor(0x06);
+  public static RED = new HairColor(0x07);
+  public static GREEN = new HairColor(0x08);
+  public static BLUE = new HairColor(0x09);
+  public static UNKNOWN = new HairColor(0xff);
+
+  private code: number;
+
+  /**
+   * Creates a hair color.
+   *
+   * @param code the integer code for a color
+   */
+  constructor(code: number) {
+    this.code = code;
+  }
+
+  /**
+   * Returns the code for this hair color.
+   *
+   * @return the code
+   */
+  public toInt(): number {
+    return this.code;
+  }
+
+  /**
+   * Returns a hair color value for the given code.
+   *
+   * @param i the integer code for a color
+   *
+   * @return the color value
+   */
+  static toHairColor(i: number): HairColor {
+    for (const c of HairColor.values()) {
+      if (c.toInt() === i) {
+        return c;
+      }
+    }
+
+    return HairColor.UNKNOWN;
+  }
+
+  static values() {
+    return [
+      HairColor.UNSPECIFIED,
+      HairColor.BALD,
+      HairColor.BLACK,
+      HairColor.BLONDE,
+      HairColor.BROWN,
+      HairColor.GRAY,
+      HairColor.WHITE,
+      HairColor.RED,
+      HairColor.GREEN,
+      HairColor.BLUE,
+      HairColor.UNKNOWN,
+    ];
+  }
+}
+
+/** Feature flags meaning based on Section 5.5.6 of ISO 19794-5. */
+export class Features {
+  public static FEATURE_FEATURES_ARE_SPECIFIED_FLAG = 0x000001;
+  public static FEATURE_GLASSES_FLAG = 0x000002;
+  public static FEATURE_MOUSTACHE_FLAG = 0x000004;
+  public static FEATURE_BEARD_FLAG = 0x000008;
+  public static FEATURE_TEETH_VISIBLE_FLAG = 0x000010;
+  public static FEATURE_BLINK_FLAG = 0x000020;
+  public static FEATURE_MOUTH_OPEN_FLAG = 0x000040;
+  public static FEATURE_LEFT_EYE_PATCH_FLAG = 0x000080;
+  public static FEATURE_RIGHT_EYE_PATCH = 0x000100;
+  public static FEATURE_DARK_GLASSES = 0x000200;
+  public static FEATURE_DISTORTING_MEDICAL_CONDITION = 0x000400;
+}
+
+/** Expression code based on Section 5.5.7 of ISO 19794-5. */
+export class Expression {
+  public static EXPRESSION_UNSPECIFIED = 0x0000;
+  public static EXPRESSION_NEUTRAL = 0x0001;
+  public static EXPRESSION_SMILE_CLOSED = 0x0002;
+  public static EXPRESSION_SMILE_OPEN = 0x0003;
+  public static EXPRESSION_RAISED_EYEBROWS = 0x0004;
+  public static EXPRESSION_EYES_LOOKING_AWAY = 0x0005;
+  public static EXPRESSION_SQUINTING = 0x0006;
+  public static EXPRESSION_FROWNING = 0x0007;
+}
+
+/** Face image type code based on Section 5.7.1 of ISO 19794-5. */
+export class FaceImageType {
+  public static FACE_IMAGE_TYPE_BASIC = 0x00;
+  public static FACE_IMAGE_TYPE_FULL_FRONTAL = 0x01;
+  public static FACE_IMAGE_TYPE_TOKEN_FRONTAL = 0x02;
+}
+
+/** Image data type code based on Section 5.7.2 of ISO 19794-5. */
+export class ImageDataType {
+  public static IMAGE_DATA_TYPE_JPEG = 0x00;
+  public static IMAGE_DATA_TYPE_JPEG2000 = 0x01;
+}
+
+/** Color space code based on Section 5.7.4 of ISO 19794-5. */
+export class ImageColorSpace {
+  public static IMAGE_COLOR_SPACE_UNSPECIFIED = 0x00;
+  public static IMAGE_COLOR_SPACE_RGB24 = 0x01;
+  public static IMAGE_COLOR_SPACE_YUV422 = 0x02;
+  public static IMAGE_COLOR_SPACE_GRAY8 = 0x03;
+  public static IMAGE_COLOR_SPACE_OTHER = 0x04;
+}
+
+/** Source type based on Section 5.7.6 of ISO 19794-5. */
+export class SourceType {
+  public static SOURCE_TYPE_UNSPECIFIED = 0x00;
+  public static SOURCE_TYPE_STATIC_PHOTO_UNKNOWN_SOURCE = 0x01;
+  public static SOURCE_TYPE_STATIC_PHOTO_DIGITAL_CAM = 0x02;
+  public static SOURCE_TYPE_STATIC_PHOTO_SCANNER = 0x03;
+  public static SOURCE_TYPE_VIDEO_FRAME_UNKNOWN_SOURCE = 0x04;
+  public static SOURCE_TYPE_VIDEO_FRAME_ANALOG_CAM = 0x05;
+  public static SOURCE_TYPE_VIDEO_FRAME_DIGITAL_CAM = 0x06;
+  public static SOURCE_TYPE_UNKNOWN = 0x07;
+}
+
+export class FaceImageInfo extends AbstractImageInfo {
+  /** Indexes into poseAngle array. */
+  private static YAW = 0;
+
+  /** Indexes into poseAngle array. */
+  private static PITCH = 1;
+
+  /** Indexes into poseAngle array. */
+  private static ROLL = 2;
+
+  private recordLength: number;
+  private gender: Gender;
+  private eyeColor: EyeColor;
+  private hairColor: number;
+  private featureMask: number;
+  private expression: number;
+  private poseAngle: number[];
+  private poseAngleUncertainty: number[];
+  private featurePoints: FeaturePoint[];
+  private faceImageType: number;
+  private imageDataType: number;
+  private colorSpace: number;
+  private sourceType: number;
+  private deviceType: number;
+  private quality: number;
+
+  /**
+   * Constructs a new face information data structure instance.
+   *
+   * @param gender gender
+   * @param eyeColor eye color
+   * @param featureMask feature mask (least significant 3 bytes)
+   * @param hairColor hair color
+   * @param expression expression
+   * @param poseAngle (encoded) pose angle
+   * @param poseAngleUncertainty pose angle uncertainty
+   * @param faceImageType face image type
+   * @param colorSpace color space
+   * @param sourceType source type
+   * @param deviceType capture device type (unspecified is <code>0x00</code>)
+   * @param quality quality
+   * @param featurePoints feature points
+   * @param width width
+   * @param height height
+   * @param imageInputStream encoded image bytes
+   * @param imageLength length of encoded image
+   * @param imageDataType either IMAGE_DATA_TYPE_JPEG or IMAGE_DATA_TYPE_JPEG2000
+   *
+   * @throws IOException on error reading input
+   */
+  constructor(
+    gender: Gender,
+    eyeColor: EyeColor,
+    featureMask: number,
+    hairColor: number,
+    expression: number,
+    poseAngle: number[],
+    poseAngleUncertainty: number[],
+    faceImageType: number,
+    colorSpace: number,
+    sourceType: number,
+    deviceType: number,
+    quality: number,
+    featurePoints: FeaturePoint[],
+    width: number,
+    height: number,
+    imageInputStream: InputStream,
+    imageLength: number,
+    imageDataType: number
+  ) {
+    super(
+      FaceImageInfo.TYPE_PORTRAIT,
+      width,
+      height,
+      imageInputStream,
+      imageLength,
+      FaceImageInfo.toMimeType(imageDataType) || 'image/jpeg'
+    );
+    if (imageInputStream == null) {
+      throw new Error('Null image');
+    }
+    this.gender = gender == null ? Gender.UNSPECIFIED : gender;
+    this.eyeColor = eyeColor == null ? EyeColor.UNSPECIFIED : eyeColor;
+    this.featureMask = featureMask;
+    this.hairColor = hairColor;
+    this.expression = expression;
+    this.colorSpace = colorSpace;
+    this.sourceType = sourceType;
+    this.deviceType = deviceType;
+    const featurePointCount = featurePoints == null ? 0 : featurePoints.length;
+    this.featurePoints = new Array<FeaturePoint>(featurePointCount);
+    if (featurePointCount > 0) {
+      this.featurePoints = featurePoints.slice();
+    }
+    this.poseAngle = poseAngle.slice();
+    this.poseAngleUncertainty = poseAngleUncertainty.slice();
+    this.imageDataType = imageDataType;
+    this.recordLength = 20 + 8 * featurePointCount + 12 + imageLength;
+
+    this.faceImageType = faceImageType;
+    this.colorSpace = colorSpace;
+    this.sourceType = sourceType;
+    this.deviceType = deviceType;
+    this.quality = quality;
+  }
+
+  // /**
+  //  * Constructs a new face information structure from binary encoding.
+  //  *
+  //  * @param inputStream an input stream
+  //  *
+  //  * @throws IOException if input cannot be read
+  //  */
+  // public FaceImageInfo(InputStream inputStream) {
+  //   super(TYPE_PORTRAIT);
+  //   readObject(inputStream);
+  protected async readObject(inputStream: InputStream): Promise<void> {
+    const dataIn =
+      inputStream instanceof DataInputStream
+        ? inputStream
+        : new DataInputStream(inputStream);
+
+    /* Facial Information Block (20), see ISO 19794-5 5.5 */
+    this.recordLength = (await dataIn.readInt()) & 0xffffffff; /* 4 */
+    const featurePointCount = await dataIn.readUnsignedShort(); /* +2 = 6 */
+    this.gender = Gender.toGender(await dataIn.readUnsignedByte()); /* +1 = 7 */
+    this.eyeColor = EyeColor.toEyeColor(
+      await dataIn.readUnsignedByte()
+    ); /* +1 = 8 */
+    this.hairColor = await dataIn.readUnsignedByte(); /* +1 = 9 */
+    this.featureMask = await dataIn.readUnsignedByte(); /* +1 = 10 */
+    this.featureMask =
+      (this.featureMask << 16) |
+      (await dataIn.readUnsignedShort()); /* +2 = 12 */
+    this.expression = await dataIn.readShort(); /* +2 = 14 */
+    this.poseAngle = new Array(3);
+    let by = await dataIn.readUnsignedByte(); /* +1 = 15 */
+    this.poseAngle[FaceImageInfo.YAW] = by;
+    let bp = await dataIn.readUnsignedByte(); /* +1 = 16 */
+    this.poseAngle[FaceImageInfo.PITCH] = bp;
+    let br = await dataIn.readUnsignedByte(); /* +1 = 17 */
+    this.poseAngle[FaceImageInfo.ROLL] = br;
+    this.poseAngleUncertainty = new Array(3);
+    this.poseAngleUncertainty[FaceImageInfo.YAW] =
+      await dataIn.readUnsignedByte(); /* +1 = 18 */
+    this.poseAngleUncertainty[FaceImageInfo.PITCH] =
+      await dataIn.readUnsignedByte(); /* +1 = 19 */
+    this.poseAngleUncertainty[FaceImageInfo.ROLL] =
+      await dataIn.readUnsignedByte(); /* +1 = 20 */
+
+    /* Feature Point(s) (optional) (8 * featurePointCount), see ISO 19794-5 5.8 */
+    this.featurePoints = new Array(featurePointCount);
+    for (let i = 0; i < featurePointCount; i++) {
+      const featureType = await dataIn.readUnsignedByte(); /* 1 */
+      const featurePoint = await dataIn.readByte(); /* +1 = 2 */
+      const x = await dataIn.readUnsignedShort(); /* +2 = 4 */
+      const y = await dataIn.readUnsignedShort(); /* +2 = 6 */
+      let skippedBytes = 0;
+      while (skippedBytes < 2) {
+        skippedBytes += await dataIn.skip(2);
+      } /* +2 = 8, NOTE: 2 bytes reserved */
+      this.featurePoints[i] = new FeaturePoint(featureType, featurePoint, x, y);
+    }
+
+    /* Image Information */
+    this.faceImageType = await dataIn.readUnsignedByte(); /* 1 */
+    this.imageDataType = await dataIn.readUnsignedByte(); /* +1 = 2 */
+    this.setWidth(await dataIn.readUnsignedShort()); /* +2 = 4 */
+    this.setHeight(await dataIn.readUnsignedShort()); /* +2 = 6 */
+    this.colorSpace = await dataIn.readUnsignedByte(); /* +1 = 7 */
+    this.sourceType = await dataIn.readUnsignedByte(); /* +1 = 8 */
+    this.deviceType = await dataIn.readUnsignedShort(); /* +2 = 10 */
+    this.quality = await dataIn.readUnsignedShort(); /* +2 = 12 */
+
+    /* Temporarily fix width and height if 0. */
+    if (this.getWidth() <= 0) {
+      this.setWidth(800);
+    }
+    if (this.getHeight() <= 0) {
+      this.setHeight(600);
+    }
+
+    /*
+     * Read image data, image data type code based on Section 5.8.1
+     * ISO 19794-5.
+     */
+    this.setMimeType(
+      FaceImageInfo.toMimeType(this.imageDataType) || 'image/jpeg'
+    );
+    const imageLength = this.recordLength - 20 - 8 * featurePointCount - 12;
+
+    await this.readImage(inputStream, imageLength);
+  }
+
+  /**
+   * Writes this face image info to output stream.
+   *
+   * @param outputStream an output stream
+   *
+   * @throws IOException if writing fails
+   */
+  public writeObject(outputStream: OutputStream): void {
+    const recordOut = new ByteArrayOutputStream();
+    this.writeFacialRecordData(recordOut);
+    const facialRecordData = recordOut.toByteArray();
+    const faceImageBlockLength = facialRecordData.length + 4;
+    const dataOut = new DataOutputStream(outputStream);
+    dataOut.write(faceImageBlockLength);
+    dataOut.writeUTF(Buffer.from(facialRecordData).toString('utf-8'));
+    dataOut.flush();
+  }
+
+  /**
+   * Returns the record length.
+   *
+   * @return the record length
+   */
+  public getRecordLength(): number {
+    /* Should be equal to (20 + 8 * featurePoints.length + 12 + getImageLength()). */
+    return this.recordLength;
+  }
+
+  /**
+   * Returns the available feature points of this face.
+   *
+   * @return feature points
+   */
+  public getFeaturePoints(): FeaturePoint[] {
+    return this.featurePoints;
+  }
+
+  /**
+   * Returns the expression
+   * (neutral, smiling, eyebrow raised, etc).
+   *
+   * @return expression
+   */
+  public getExpression(): number {
+    return this.expression;
+  }
+
+  /**
+   * Returns the eye color
+   * (black, blue, brown, etc).
+   *
+   * @return eye color
+   */
+  public getEyeColor(): EyeColor {
+    return this.eyeColor;
+  }
+
+  /**
+   * Returns the gender
+   * (male, female, etc).
+   *
+   * @return gender
+   */
+  public getGender(): Gender {
+    return this.gender;
+  }
+
+  /**
+   * Returns the hair color
+   * (bald, black, blonde, etc).
+   *
+   * @return hair color
+   */
+  public getHairColor(): number {
+    return this.hairColor;
+  }
+
+  /**
+   * Returns the face image type
+   * (full frontal, token frontal, etc).
+   *
+   * @return face image type
+   */
+  public getFaceImageType(): number {
+    return this.faceImageType;
+  }
+
+  /**
+   * Returns the feature mask.
+   *
+   * @return feature mask
+   */
+  public getFeatureMask(): number {
+    return this.featureMask;
+  }
+
+  /**
+   * Returns the quality as unsigned integer.
+   *
+   * @return quality
+   */
+  public getQuality(): number {
+    return this.quality;
+  }
+
+  /**
+   * Returns the source type
+   * (camera, scanner, etc).
+   *
+   * @return source type
+   */
+  public getSourceType(): number {
+    return this.sourceType;
+  }
+
+  /**
+   * Returns the image data type.
+   *
+   * @return image data type
+   */
+  public getImageDataType(): number {
+    return this.imageDataType;
+  }
+
+  /**
+   * Returns the image color space
+   * (rgb, grayscale, etc).
+   *
+   * @return image color space
+   */
+  public getColorSpace(): number {
+    return this.colorSpace;
+  }
+
+  /**
+   * Returns the device type.
+   *
+   * @return device type
+   */
+  public getDeviceType(): number {
+    return this.deviceType;
+  }
+
+  /**
+   * Returns the pose angle as an integer array of length 3,
+   * containing yaw, pitch, and roll angle in encoded form.
+   *
+   * @return an integer array of length 3
+   */
+  public getPoseAngle(): number[] {
+    const result: number[] = [];
+    result.push(...this.poseAngle);
+    return result;
+  }
+
+  /**
+   * Returns the pose angle uncertainty as an integer array of length 3,
+   * containing yaw, pitch, and roll angle uncertainty.
+   *
+   * @return an integer array of length 3
+   */
+  public getPoseAngleUncertainty(): number[] {
+    const result: number[] = [];
+    result.push(...this.poseAngleUncertainty);
+    return result;
+  }
+
+  /**
+   * Writes the record data to a stream.
+   *
+   * @param outputStream the stream to write to
+   *
+   * @throws IOException on error
+   */
+  private async writeFacialRecordData(
+    outputStream: OutputStream
+  ): Promise<void> {
+    const dataOut = new DataOutputStream(outputStream);
+
+    /* Facial Information (16) */
+    dataOut.write(this.featurePoints.length); /* 2 */
+    dataOut.write(
+      this.gender == null ? Gender.UNSPECIFIED.getCode() : this.gender.getCode()
+    ); /* 1 */
+    dataOut.write(
+      this.eyeColor == null
+        ? EyeColor.UNSPECIFIED.toInt()
+        : this.eyeColor.toInt()
+    ); /* 1 */
+    dataOut.write(this.hairColor); /* 1 */
+    dataOut.write((this.featureMask & 0xff0000) >> 16); /* 1 */
+    dataOut.write((this.featureMask & 0x00ff00) >> 8); /* 1 */
+    dataOut.write(this.featureMask & 0x0000ff); /* 1 */
+    dataOut.write(this.expression); /* 2 */
+    for (let i = 0; i < 3; i++) {
+      /* 3 */
+      const b = this.poseAngle[i];
+      dataOut.write(b);
+    }
+    for (let i = 0; i < 3; i++) {
+      /* 3 */
+      dataOut.write(this.poseAngleUncertainty[i]);
+    }
+
+    /* Feature Point(s) (optional) (8 * featurePointCount) */
+    for (const fp of this.featurePoints) {
+      dataOut.write(fp.getType());
+      dataOut.write((fp.getMajorCode() << 4) | fp.getMinorCode());
+      dataOut.write(fp.getX());
+      dataOut.write(fp.getY());
+      dataOut.write(0x00); /* 2 bytes RFU */
+    }
+
+    /* Image Information (12) */
+    dataOut.write(this.faceImageType); /* 1 */
+    dataOut.write(this.imageDataType); /* 1 */
+    dataOut.write(this.getWidth()); /* 2 */
+    dataOut.write(this.getHeight()); /* 2 */
+    dataOut.write(this.colorSpace); /* 1 */
+    dataOut.write(this.sourceType); /* 1 */
+    dataOut.write(this.deviceType); /* 2 */
+    dataOut.write(this.quality); /* 2 */
+
+    /*
+     * Image data type code based on Section 5.8.1
+     * ISO 19794-5
+     */
+    await this.writeImage(dataOut);
+    dataOut.flush();
+    dataOut.close();
+  }
+
+  /**
+   * Converts a hair color value to a human readable string.
+   *
+   * @return a human readable string for the current hair color value
+   */
+  private hairColorToString(): string {
+    switch (this.hairColor) {
+      case HairColor.UNSPECIFIED.toInt():
+        return 'unspecified';
+      case HairColor.BALD.toInt():
+        return 'bald';
+      case HairColor.BLACK.toInt():
+        return 'black';
+      case HairColor.BLONDE.toInt():
+        return 'blonde';
+      case HairColor.BROWN.toInt():
+        return 'brown';
+      case HairColor.GRAY.toInt():
+        return 'gray';
+      case HairColor.WHITE.toInt():
+        return 'white';
+      case HairColor.RED.toInt():
+        return 'red';
+      case HairColor.GREEN.toInt():
+        return 'green';
+      case HairColor.BLUE.toInt():
+        return 'blue';
+      default:
+        return 'unknown';
+    }
+  }
+
+  /**
+   * Returns a human readable string for the current feature mask.
+   *
+   * @return a human readable string
+   */
+  private featureMaskToString(): string {
+    if (
+      (this.featureMask & Features.FEATURE_FEATURES_ARE_SPECIFIED_FLAG) ===
+      0
+    ) {
+      return '';
+    }
+    const features: string[] = [];
+    if ((this.featureMask & Features.FEATURE_GLASSES_FLAG) !== 0) {
+      features.push('glasses');
+    }
+    if ((this.featureMask & Features.FEATURE_MOUSTACHE_FLAG) !== 0) {
+      features.push('moustache');
+    }
+    if ((this.featureMask & Features.FEATURE_BEARD_FLAG) !== 0) {
+      features.push('beard');
+    }
+    if ((this.featureMask & Features.FEATURE_TEETH_VISIBLE_FLAG) !== 0) {
+      features.push('teeth visible');
+    }
+    if ((this.featureMask & Features.FEATURE_BLINK_FLAG) !== 0) {
+      features.push('blink');
+    }
+    if ((this.featureMask & Features.FEATURE_MOUTH_OPEN_FLAG) !== 0) {
+      features.push('mouth open');
+    }
+    if ((this.featureMask & Features.FEATURE_LEFT_EYE_PATCH_FLAG) !== 0) {
+      features.push('left eye patch');
+    }
+    if ((this.featureMask & Features.FEATURE_RIGHT_EYE_PATCH) !== 0) {
+      features.push('right eye patch');
+    }
+    if ((this.featureMask & Features.FEATURE_DARK_GLASSES) !== 0) {
+      features.push('dark glasses');
+    }
+    if (
+      (this.featureMask & Features.FEATURE_DISTORTING_MEDICAL_CONDITION) !==
+      0
+    ) {
+      features.push(
+        'distorting medical condition (which could impact feature point detection)'
+      );
+    }
+    return features.join(', ');
+  }
+
+  /**
+   * Converts the current expression to a human readable string.
+   *
+   * @return a human readable string
+   */
+  private expressionToString(): string {
+    switch (this.expression) {
+      case Expression.EXPRESSION_UNSPECIFIED:
+        return 'unspecified';
+      case Expression.EXPRESSION_NEUTRAL:
+        return 'neutral (non-smiling) with both eyes open and mouth closed';
+      case Expression.EXPRESSION_SMILE_CLOSED:
+        return 'a smile where the inside of the mouth and/or teeth is not exposed (closed jaw)';
+      case Expression.EXPRESSION_SMILE_OPEN:
+        return 'a smile where the inside of the mouth and/or teeth is exposed';
+      case Expression.EXPRESSION_RAISED_EYEBROWS:
+        return 'raised eyebrows';
+      case Expression.EXPRESSION_EYES_LOOKING_AWAY:
+        return 'eyes looking away from the camera';
+      case Expression.EXPRESSION_SQUINTING:
+        return 'squinting';
+      case Expression.EXPRESSION_FROWNING:
+        return 'frowning';
+      default:
+        return 'unknown';
+    }
+  }
+
+  /**
+   * Converts the current pose angle to a human readable string.
+   *
+   * @return a human readable string
+   */
+  private poseAngleToString(): string {
+    let out: string = '(';
+    out += 'y: ' + this.poseAngle[FaceImageInfo.YAW];
+    if (this.poseAngleUncertainty[FaceImageInfo.YAW] !== 0) {
+      out += ' (' + this.poseAngleUncertainty[FaceImageInfo.YAW] + ')';
+    }
+    out += ', ';
+    out += 'p:' + this.poseAngle[FaceImageInfo.PITCH];
+    if (this.poseAngleUncertainty[FaceImageInfo.PITCH] !== 0) {
+      out += ' (' + this.poseAngleUncertainty[FaceImageInfo.PITCH] + ')';
+    }
+    out += ', ';
+    out += 'r: ' + this.poseAngle[FaceImageInfo.ROLL];
+    if (this.poseAngleUncertainty[FaceImageInfo.ROLL] !== 0) {
+      out += ' (' + this.poseAngleUncertainty[FaceImageInfo.ROLL] + ')';
+    }
+    out += ')';
+    return out;
+  }
+
+  /**
+   * Returns a textual representation of the face image type
+   * ({@code "basic"}, {@code "full frontal"}, {@code "token frontal"},
+   * or {@code "unknown"}).
+   *
+   * @return a textual representation of the face image type
+   */
+  private faceImageTypeToString(): string {
+    switch (this.faceImageType) {
+      case FaceImageType.FACE_IMAGE_TYPE_BASIC:
+        return 'basic';
+      case FaceImageType.FACE_IMAGE_TYPE_FULL_FRONTAL:
+        return 'full frontal';
+      case FaceImageType.FACE_IMAGE_TYPE_TOKEN_FRONTAL:
+        return 'token frontal';
+      default:
+        return 'unknown';
+    }
+  }
+
+  /**
+   * Returns a textual representation of the source type.
+   *
+   * @return a textual representation of the source type
+   */
+  private sourceTypeToString(): string {
+    switch (this.sourceType) {
+      case SourceType.SOURCE_TYPE_UNSPECIFIED:
+        return 'unspecified';
+      case SourceType.SOURCE_TYPE_STATIC_PHOTO_UNKNOWN_SOURCE:
+        return 'static photograph from an unknown source';
+      case SourceType.SOURCE_TYPE_STATIC_PHOTO_DIGITAL_CAM:
+        return 'static photograph from a digital still-image camera';
+      case SourceType.SOURCE_TYPE_STATIC_PHOTO_SCANNER:
+        return 'static photograph from a scanner';
+      case SourceType.SOURCE_TYPE_VIDEO_FRAME_UNKNOWN_SOURCE:
+        return 'single video frame from an unknown source';
+      case SourceType.SOURCE_TYPE_VIDEO_FRAME_ANALOG_CAM:
+        return 'single video frame from an analogue camera';
+      case SourceType.SOURCE_TYPE_VIDEO_FRAME_DIGITAL_CAM:
+        return 'single video frame from a digital camera';
+      default:
+        return 'unknown';
+    }
+  }
+
+  /**
+   * Returns a mime-type string for the compression algorithm code.
+   *
+   * @param compressionAlg the compression algorithm code as it occurs in the header
+   *
+   * @return a mime-type string,
+   *         typically {@code JPEG_MIME_TYPE} or {@code JPEG2000_MIME_TYPE}
+   */
+  private static toMimeType(compressionAlg: number) {
+    switch (compressionAlg) {
+      case ImageDataType.IMAGE_DATA_TYPE_JPEG:
+        return FaceImageInfo.JPEG_MIME_TYPE;
+      case ImageDataType.IMAGE_DATA_TYPE_JPEG2000:
+        return FaceImageInfo.JPEG2000_MIME_TYPE;
+      default:
+        console.debug('Unknown image type: ' + compressionAlg);
+        return null;
+    }
+  }
+
+  public static async from(inputStream: InputStream): Promise<FaceImageInfo> {
+    const faceImageInfo = new FaceImageInfo(
+      Gender.UNSPECIFIED,
+      EyeColor.UNSPECIFIED,
+      0,
+      0,
+      0,
+      [0, 0, 0],
+      [0, 0, 0],
+      0,
+      0,
+      0,
+      0,
+      0,
+      [],
+      0,
+      0,
+      inputStream,
+      0,
+      0
+    );
+    await faceImageInfo.readObject(inputStream);
+    return faceImageInfo;
+  }
+}