First commit.

.gitignore

@@ -0,0 +1,75 @@
+# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.buildlog/
+.history
+.svn/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+#.vscode/
+
+# Flutter/Dart/Pub related
+**/doc/api/
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+.packages
+.pub-cache/
+.pub/
+build/
+
+# Android related
+**/android/**/gradle-wrapper.jar
+**/android/.gradle
+**/android/captures/
+**/android/gradlew
+**/android/gradlew.bat
+**/android/local.properties
+**/android/**/GeneratedPluginRegistrant.java
+
+# iOS/XCode related
+**/ios/**/*.mode1v3
+**/ios/**/*.mode2v3
+**/ios/**/*.moved-aside
+**/ios/**/*.pbxuser
+**/ios/**/*.perspectivev3
+**/ios/**/*sync/
+**/ios/**/.sconsign.dblite
+**/ios/**/.tags*
+**/ios/**/.vagrant/
+**/ios/**/DerivedData/
+**/ios/**/Icon?
+**/ios/**/Pods/
+**/ios/**/.symlinks/
+**/ios/**/profile
+**/ios/**/xcuserdata
+**/ios/.generated/
+**/ios/Flutter/App.framework
+**/ios/Flutter/Flutter.framework
+**/ios/Flutter/Flutter.podspec
+**/ios/Flutter/Generated.xcconfig
+**/ios/Flutter/ephemeral
+**/ios/Flutter/app.flx
+**/ios/Flutter/app.zip
+**/ios/Flutter/flutter_assets/
+**/ios/Flutter/flutter_export_environment.sh
+**/ios/ServiceDefinitions.json
+**/ios/Runner/GeneratedPluginRegistrant.*
+
+# Exceptions to above rules.
+!**/ios/**/default.mode1v3
+!**/ios/**/default.mode2v3
+!**/ios/**/default.pbxuser
+!**/ios/**/default.perspectivev3

.metadata

@@ -0,0 +1,10 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: f4abaa0735eba4dfd8f33f73363911d63931fe03
+  channel: stable
+
+project_type: package

.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "vid",
+            "request": "launch",
+            "type": "dart"
+        },
+        {
+            "name": "vid (profile mode)",
+            "request": "launch",
+            "type": "dart",
+            "flutterMode": "profile"
+        }
+    ]
+}

CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.0.1
+
+* TODO: Describe initial release.

LICENSE

@@ -0,0 +1 @@
+TODO: Add your license here.

README.md

@@ -0,0 +1,14 @@
+# vid
+
+A new Flutter package project.
+
+## Getting Started
+
+This project is a starting point for a Dart
+[package](https://flutter.dev/developing-packages/),
+a library module containing code that can be shared easily across
+multiple Flutter or Dart projects.
+
+For help getting started with Flutter, view our 
+[online documentation](https://flutter.dev/docs), which offers tutorials, 
+samples, guidance on mobile development, and a full API reference.

lib/us/vid_us_2d_visual.dart

@@ -0,0 +1,93 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+import 'package:vid/us/vid_us_display_mode.dart';
+import 'package:vid/us/vid_us_logical_coordinate.dart';
+import 'package:vid/us/vid_us_mode.dart';
+import 'package:vid/us/vid_us_physical_coordinate.dart';
+import 'package:vid/us/vid_us_visual.dart';
+import 'package:vid/us/vid_us_visual_area_type.dart';
+import 'package:vid/us/vid_us_visual_indicator.dart';
+import 'package:vid/us/vid_us_visual_type.dart';
+
+class VidUs2DVisual extends VidUsVisual {
+  late Map<VidUsVisualAreaType, VidUsLogicalCoordinate> _logicalCoordinates;
+
+  late Map<VidUsVisualAreaType, VidUsPhysicalCoordinate> _physicalCoordinates;
+
+  /// Get all LogicalCoordinates of this visual.
+  Map<VidUsVisualAreaType, VidUsLogicalCoordinate> get logicalCoordinates =>
+      _logicalCoordinates;
+
+  ///Get all PhysicalCoordinates of this visual.
+  Map<VidUsVisualAreaType, VidUsPhysicalCoordinate> get physicalCoordinates =>
+      _physicalCoordinates;
+
+  VidUs2DVisual() {
+    setVisualType(VidUsVisualType.V2D);
+    _logicalCoordinates =
+        new Map<VidUsVisualAreaType, VidUsLogicalCoordinate>();
+    _physicalCoordinates =
+        new Map<VidUsVisualAreaType, VidUsPhysicalCoordinate>();
+  }
+
+  ///Convert VidUs2DVisual to binary data.
+  @override
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeByte(_physicalCoordinates.length);
+    _physicalCoordinates.forEach((key, value) {
+      writer.writeByte(key.index);
+      writer.writeBytes(value.toBytes());
+    });
+    writer.writeByte(_logicalCoordinates.length);
+    _logicalCoordinates.forEach((key, value) {
+      writer.writeByte(key.index);
+      writer.writeBytes(value.toBytes());
+    });
+    return writer.data;
+  }
+
+  ///Convert binary data to VidUs2DVisual.
+  static VidUsVisual fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var visualType = VidUsVisualType.values[reader.readByte()];
+    var displayMode = VidUsDisplayMode.values[reader.readByte()];
+    if (visualType == VidUsVisualType.V2D) {
+      var indicator = VidUsVisualIndicator.values[reader.readByte()];
+      var activeModeType = VidUsModeType.values[reader.readByte()];
+      var modeCount = reader.readByte();
+      List<VidUsMode> modes = [];
+      for (var i = 0; i < modeCount; i++) {
+        var mode = VidUsMode.fromBytes(reader.readBytes());
+        modes.add(mode);
+      }
+      var visual = new VidUs2DVisual();
+      visual.setIndicator(indicator);
+      modes.forEach((mode) {
+        visual.modes.add(mode);
+      });
+      visual..setActiveModeType(activeModeType);
+      var physicalCoordinateCount = reader.readByte();
+      for (var i = 0; i < physicalCoordinateCount; i++) {
+        var visualAreaType = VidUsVisualAreaType.values[reader.readByte()];
+        var physicalCoordinate =
+            VidUsPhysicalCoordinate.fromBytes(reader.readBytes());
+        visual._physicalCoordinates[visualAreaType] = physicalCoordinate;
+      }
+      var logicalCoordinateCount = reader.readByte();
+      for (var i = 0; i < logicalCoordinateCount; i++) {
+        var visualAreaType = VidUsVisualAreaType.values[reader.readByte()];
+        var logicalCoordinate =
+            VidUsLogicalCoordinate.fromBytes(reader.readBytes());
+        visual._logicalCoordinates[visualAreaType] = logicalCoordinate;
+      }
+      visual.setDisplayMode(displayMode);
+      return visual;
+    }
+    throw new Exception(
+        "Can not restore visual data from $visualType to VidUs2DVisual.");
+  }
+}

lib/us/vid_us_3d_visual.dart

@@ -0,0 +1,62 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+import 'package:vid/us/vid_us_display_mode.dart';
+import 'package:vid/us/vid_us_mode.dart';
+import 'package:vid/us/vid_us_tissue_3d_area.dart';
+import 'package:vid/us/vid_us_visual.dart';
+import 'package:vid/us/vid_us_visual_indicator.dart';
+import 'package:vid/us/vid_us_visual_type.dart';
+
+class VidUs3DVisual extends VidUsVisual {
+  late List<VidUsTissue3DArea> _tissue3DAreas;
+
+  /// Gets the tissue 3d areas for this visual.
+  List<VidUsTissue3DArea> get tissue3DAreas => _tissue3DAreas;
+
+  VidUs3DVisual() {
+    super.setVisualType(VidUsVisualType.V3D);
+    _tissue3DAreas = [];
+  }
+
+  ///Convert VidUs3DVisual to binary data.
+  @override
+  Uint8List toBytes() {
+    var baseData = super.toBytes();
+    var writer = new VidUsDataWriter();
+    writer.writeBytes(baseData);
+    writer.writeByte(_tissue3DAreas.length);
+    _tissue3DAreas.forEach((area) {
+      writer.writeBytes(area.toBytes());
+    });
+    return writer.data;
+  }
+
+  ///Convert binary data to VidUs3DVisual.
+  static VidUsVisual fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var visualType = VidUsVisualType.values[reader.readByte()];
+    var displayMode = VidUsDisplayMode.values[reader.readByte()];
+    if (visualType == VidUsVisualType.V3D) {
+      var indicator = VidUsVisualIndicator.values[reader.readByte()];
+      var visual = new VidUs3DVisual();
+      visual.setIndicator(indicator);
+      var activeModeType = VidUsModeType.values[reader.readByte()];
+      var modeCount = reader.readByte();
+      for (int i = 0; i < modeCount; i++) {
+        var mode = VidUsMode.fromBytes(reader.readBytes());
+        visual.modes.add(mode);
+      }
+      visual.setActiveModeType(activeModeType);
+      var tissue3DAreaCount = reader.readByte();
+      for (int i = 0; i < tissue3DAreaCount; i++) {
+        var tissue3DArea = VidUsTissue3DArea.fromBytes(reader.readBytes());
+        visual.tissue3DAreas.add(tissue3DArea);
+      }
+      visual.setDisplayMode(displayMode);
+      return visual;
+    }
+    throw new Exception(
+        "Can not restore visual data from $visualType to VidUs3DVisual.");
+  }
+}

lib/us/vid_us_application.dart

@@ -0,0 +1,66 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+
+class VidUsApplication {
+  late String _applicationId;
+
+  late String _applicationOriginalId;
+
+  late String _applicationName;
+
+  late String _applicationCategoryName;
+
+  late bool _isUserDefined;
+
+  /// Gets the application's ID
+  String get applicationId => _applicationId;
+
+  /// Gets the OriginalId of the applciation.
+  String get applicationOriginalId => _applicationOriginalId;
+
+  /// Gets the application's name.
+  String get applicationName => _applicationName;
+
+  /// Gets the applciation's category name.
+  String get applicationCategoryName => _applicationCategoryName;
+
+  /// Gets if is user defined.
+  bool get isUserDefined => _isUserDefined;
+
+  VidUsApplication(
+      String applicationId,
+      String applicationOriginalId,
+      String applicationName,
+      String applicationCategoryName,
+      bool isUserDefined) {
+    _applicationId = applicationId;
+    _applicationOriginalId = applicationOriginalId;
+    _applicationName = applicationName;
+    _applicationCategoryName = applicationCategoryName;
+    _isUserDefined = isUserDefined;
+  }
+
+  ///Convert VidUsApplication to binary data.
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeString(_applicationId);
+    writer.writeString(_applicationOriginalId);
+    writer.writeString(_applicationName);
+    writer.writeString(_applicationCategoryName);
+    writer.writeBool(_isUserDefined);
+    return writer.data;
+  }
+
+  ///Convert binary data to VidUsApplication.
+  static VidUsApplication fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var applicationId = reader.readString();
+    var applicationOriginalId = reader.readString();
+    var applicationName = reader.readString();
+    var applicationCategoryName = reader.readString();
+    var isUserDefined = reader.readBool();
+    return new VidUsApplication(applicationId, applicationOriginalId,
+        applicationName, applicationCategoryName, isUserDefined);
+  }
+}

lib/us/vid_us_data_reader.dart

@@ -0,0 +1,169 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+class VidUsDataReader {
+  late final ByteBuffer _buffer;
+  late int _index;
+
+  VidUsDataReader(Uint8List data, [int offset = 0]) {
+    _buffer = data.buffer;
+    _index = data.offsetInBytes + offset;
+  }
+
+  ///Read int value from binary data(little endian),
+  int readInt([int index = -1]) {
+    if (index == -1) {
+      var intData = _buffer.asByteData(_index, 4);
+      _index += 4;
+      return intData.getInt32(0, Endian.little);
+    } else {
+      var intData = _buffer.asByteData(index, 4);
+      _index = index + 4;
+      return intData.getInt32(0, Endian.little);
+    }
+  }
+
+  ///Read string from the binary data, the string format is utf8
+  String readString([int index = -1]) {
+    if (index == -1) {
+      var dataLength = readInt();
+      var stringData = _buffer.asUint8List(_index, dataLength);
+      _index += dataLength;
+      return utf8.decode(stringData);
+    } else {
+      var dataLength = readInt(index);
+      var stringData = _buffer.asUint8List(_index, dataLength);
+      _index += dataLength;
+      return utf8.decode(stringData);
+    }
+  }
+
+  ///Read int16 value from binary data(little endian)
+  int readInt16([int index = -1]) {
+    if (index == -1) {
+      var intData = _buffer.asByteData(_index, 2);
+      _index += 2;
+      return intData.getInt16(0, Endian.little);
+    } else {
+      var intData = _buffer.asByteData(index, 2);
+      _index = index + 2;
+      return intData.getInt16(0, Endian.little);
+    }
+  }
+
+  ///Read int64 value from binary data(little endian)
+  ///this method is not support in web platform use readInt64V2 instead.
+  int readInt64([int index = -1]) {
+    if (index == -1) {
+      var intData = _buffer.asByteData(_index, 8);
+      _index += 8;
+      return intData.getInt64(0, Endian.little);
+    } else {
+      var intData = _buffer.asByteData(index, 8);
+      _index = index + 8;
+      return intData.getInt64(0, Endian.little);
+    }
+  }
+
+  ///Read int64 value from binary data(little endian)
+  ///this method use two int32 to support read int64 on web platform
+  int readInt64V2([int index = -1]) {
+    if (index == -1) {
+      int low = readInt();
+      int high = readInt();
+      int value = high >> 32;
+      value |= low;
+      return value;
+    } else {
+      int low = readInt(index);
+      int high = readInt();
+      int value = high >> 32;
+      value |= low;
+      return value;
+    }
+  }
+
+  ///Read float value from binary data(little endian)
+  double readFloat([int index = -1]) {
+    if (index == -1) {
+      var floatData = _buffer.asByteData(_index, 4);
+      _index += 4;
+      return floatData.getFloat32(0, Endian.little);
+    } else {
+      var floatData = _buffer.asByteData(index, 4);
+      _index = index + 4;
+      return floatData.getFloat32(0, Endian.little);
+    }
+  }
+
+  ///Read double value from binary data(little endian)
+  double readDouble([int index = -1]) {
+    if (index == -1) {
+      var floatData = _buffer.asByteData(_index, 8);
+      _index += 8;
+      return floatData.getFloat64(0, Endian.little);
+    } else {
+      var floatData = _buffer.asByteData(index, 8);
+      _index = index + 8;
+      return floatData.getFloat64(0, Endian.little);
+    }
+  }
+
+  ///Read bool value from binary data
+  bool readBool([int index = -1]) {
+    if (index == -1) {
+      var boolData = _buffer.asByteData(_index, 1);
+      _index++;
+      return boolData.getInt8(0) == 1;
+    } else {
+      var boolData = _buffer.asByteData(index, 1);
+      _index++;
+      return boolData.getInt8(0) == 1;
+    }
+  }
+
+  ///Read byte value from binary data
+  int readByte([int index = -1]) {
+    if (index == -1) {
+      var byteData = _buffer.asByteData(_index, 1);
+      _index++;
+      return byteData.getInt8(0);
+    } else {
+      var byteData = _buffer.asByteData(index, 1);
+      _index++;
+      return byteData.getInt8(0);
+    }
+  }
+
+  ///Read bytes from the binary data.
+  Uint8List readBytes([int index = -1]) {
+    var dataLength = readInt(index);
+    var bytes = _buffer.asUint8List(_index, dataLength);
+    _index += dataLength;
+    return bytes;
+  }
+
+  int _readLong(Uint8List longData) {
+    int low = longData.buffer
+        .asByteData(longData.offsetInBytes)
+        .getInt32(0, Endian.little);
+    int high = longData.buffer
+        .asByteData(longData.offsetInBytes)
+        .getInt32(4, Endian.little);
+    int value = high >> 32;
+    value |= low;
+    return value;
+  }
+
+  ///Read a group of int64 values from the binary data.
+  List<int> readLongs() {
+    var longData = readBytes();
+    var longCount = longData.length ~/ 8;
+    List<int> result = [];
+    for (var i = 0; i < longCount; i++) {
+      result.add(_readLong(
+          longData.buffer.asUint8List(longData.offsetInBytes + i * 8, 8)));
+    }
+    return result;
+  }
+}

lib/us/vid_us_data_writer.dart

@@ -0,0 +1,64 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+///Not used for now.
+class VidUsDataWriter {
+  final BytesBuilder _builder = new BytesBuilder();
+
+  Uint8List get data => _builder.toBytes();
+
+  void writeString(String value) {
+    var data = utf8.encode(value);
+    var length = data.length;
+    writeInt(length);
+    _builder.add(data);
+  }
+
+  void writeInt(int value) {
+    var data = Uint8List(4);
+    data.buffer.asByteData().setInt32(0, value, Endian.little);
+    _builder.add(data);
+  }
+
+  void writeInt16(int value) {
+    var data = Uint8List(2);
+    data.buffer.asByteData().setInt16(0, value, Endian.little);
+    _builder.add(data);
+  }
+
+  void writeInt64(int value) {
+    var data = Uint8List(8);
+    data.buffer.asByteData().setInt64(0, value, Endian.little);
+    _builder.add(data);
+  }
+
+  void writeFloat(double value) {
+    var data = Uint8List(4);
+    data.buffer.asByteData().setFloat32(0, value, Endian.little);
+    _builder.add(data);
+  }
+
+  void writeDouble(double value) {
+    var data = Uint8List(8);
+    data.buffer.asByteData().setFloat64(0, value, Endian.little);
+    _builder.add(data);
+  }
+
+  void writeBool(bool value) {
+    _builder.addByte(value ? 1 : 0);
+  }
+
+  void writeByte(int value) {
+    _builder.addByte(value);
+  }
+
+  void writeBytes(Uint8List value) {
+    writeInt(value.length);
+    _builder.add(value);
+  }
+
+  void writeLongs(Int64List value) {
+    _builder.add(value.buffer.asUint8List());
+  }
+}

lib/us/vid_us_display_mode.dart

@@ -0,0 +1,27 @@
+enum VidUsDisplayMode {
+  /// Normal B mode
+  Normal,
+
+  /// Up/Down, B holds 1/3, Other hodes 2/3
+  UpDown13B,
+
+  /// Up/Down, half, half
+  UpDownHalfHalf,
+
+  /// Up/Down, B holds2/3, Other hodes1/3
+  UpDown23B,
+
+  ///// Left/Right, B holds 1/3, other hodes 2/3
+  //SideBySide13B = 3,
+
+  /// Left/Right, half, half
+  SideBySideHalfHalf,
+
+  /// Left/Right, B holds2/3, Other hodes1/3
+  SideBySide14BOther,
+
+  /// All Image area are Other image instead of B image
+  FullOther,
+
+  FullTissue,
+}

lib/us/vid_us_image.dart

@@ -0,0 +1,87 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+import 'package:vid/us/vid_us_visual.dart';
+
+/// Used for update the image data.
+abstract class IImageDataContainer {
+  abstract Uint8List imageData;
+}
+
+/// This class is used for updating the image data.
+class VidUsImageUpdater {
+  final IImageDataContainer _imageDataContainer;
+
+  VidUsImageUpdater(this._imageDataContainer);
+
+  /// Update image data
+  void update(Uint8List imageData) {
+    _imageDataContainer.imageData = imageData;
+  }
+}
+
+class VidUsImage implements IImageDataContainer {
+  @override
+  late Uint8List imageData;
+
+  late int _index;
+  late int _width;
+  late int _height;
+  late List<VidUsVisual> _visuals;
+
+  /// Gets the index of this image.
+  int get index => _index;
+
+  /// Gets the width of this image data.
+  int get width => _width;
+
+  /// Gets the height of this image data.
+  int get height => _height;
+
+  /// Gets all visuals of this image.
+  List<VidUsVisual> get visuals => _visuals;
+
+  VidUsImage(int index, int width, int height, Uint8List data) {
+    _visuals = [];
+    _index = index;
+    _width = width;
+    _height = height;
+    imageData = data;
+  }
+
+  /// VidUsImage image to binary data.
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeInt(_index);
+    writer.writeByte(_visuals.length);
+    _visuals.forEach((visual) {
+      var visualData = visual.toBytes();
+      writer.writeBytes(visualData);
+    });
+    writer.writeInt16(_width);
+    writer.writeInt16(_height);
+    writer.writeBytes(imageData);
+    return writer.data;
+  }
+
+  /// Convert binary data to VidUsImage
+  static VidUsImage fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var index = reader.readInt();
+    var visualCount = reader.readByte();
+    List<VidUsVisual> visuals = [];
+    for (int i = 0; i < visualCount; i++) {
+      var visual = VidUsVisual.fromBytes(reader.readBytes());
+      visuals.add(visual);
+    }
+    var width = reader.readInt16();
+    var height = reader.readInt16();
+    var imageData = reader.readBytes();
+    var result = new VidUsImage(index, width, height, imageData);
+    visuals.forEach((visual) {
+      result._visuals.add(visual);
+    });
+
+    return result;
+  }
+}

lib/us/vid_us_image_data.dart

@@ -0,0 +1,69 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_image.dart';
+import 'package:vid/us/vid_us_probe.dart';
+
+enum VidUsImageFormat {
+  Jpeg,
+  Png,
+  H264,
+  Zip,
+  Diff,
+}
+
+///Only suport read for now.
+///Not suport carotid3d for now.
+class VidUsImageData {
+  late VidUsDataReader _reader;
+  late List<int> _imagePositionList;
+  late int _version;
+  late int _imageCount;
+  late VidUsProbe _probe;
+  late VidUsImageFormat _imageFormat;
+  late Uint8List _extendedData;
+
+  final String header = "VINNO IMAGE DATA";
+
+  /// Gets the version of this image data.
+  int get version => _version;
+
+  /// Gets the image count of this image data.
+  int get imageCount => _imageCount;
+
+  /// Gets the probe information.
+  VidUsProbe get probe => _probe;
+
+  /// Gets the image format of this image data.
+  VidUsImageFormat get imageFormat => _imageFormat;
+
+  /// Gets or sets the extended data.
+  Uint8List get extendedData => _extendedData;
+
+  /// Create a VINNO Image Data.
+  VidUsImageData(Uint8List data) {
+    _reader = new VidUsDataReader(data);
+    var header = _reader.readString();
+    if (header != header) {
+      throw new Exception("The input data is not a VID data.");
+    }
+    _version = _reader.readInt();
+    //Get probe info
+    var probeData = _reader.readBytes();
+    _probe = VidUsProbe.fromBytes(probeData);
+    _imageFormat = VidUsImageFormat.values[_reader.readInt()];
+    _extendedData = _reader.readBytes();
+    //Get the index list.
+    _imagePositionList = _reader.readLongs();
+    _imageCount = _imagePositionList.length;
+  }
+
+  /// Get one image from the vid.
+  VidUsImage getImage(int index) {
+    if (index >= _imageCount || index < 0) {
+      throw new Exception("Can not find image Data");
+    }
+    //Jump to image.
+    var imageData = _reader.readBytes(_imagePositionList[index]);
+    return VidUsImage.fromBytes(imageData);
+  }
+}

lib/us/vid_us_logical_coordinate.dart

@@ -0,0 +1,56 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+import 'package:vid/us/vid_us_point.dart';
+import 'package:vid/us/vid_us_rect.dart';
+import 'package:vid/us/vid_us_unit.dart';
+
+class VidUsLogicalCoordinate {
+  bool _isFlipHorizontal;
+  bool _isFlipVertical;
+  VidUsRect _region;
+  VidUsUnit _xUnit;
+  VidUsUnit _yUnit;
+
+  bool get isFlipHorizontal => _isFlipHorizontal;
+
+  bool get isFlipVertical => _isFlipVertical;
+
+  VidUsRect get region => _region;
+
+  VidUsUnit get xUnit => _xUnit;
+
+  VidUsUnit get yUnit => _yUnit;
+
+  VidUsLogicalCoordinate(this._isFlipHorizontal, this._isFlipVertical,
+      this._region, this._xUnit, this._yUnit);
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeBool(_isFlipHorizontal);
+    writer.writeBool(_isFlipVertical);
+    writer.writeByte(VidUsUnitMap.getUnitValue(_xUnit));
+    writer.writeByte(VidUsUnitMap.getUnitValue(_yUnit));
+    writer.writeDouble(_region.left);
+    writer.writeDouble(_region.top);
+    writer.writeDouble(_region.right);
+    writer.writeDouble(_region.bottom);
+    return writer.data;
+  }
+
+  static VidUsLogicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var isFlipHorizontal = reader.readBool();
+    var isFlipVertical = reader.readBool();
+    var xUnit = VidUsUnitMap.getUnit(reader.readByte());
+    var yUnit = VidUsUnitMap.getUnit(reader.readByte());
+    var left = reader.readDouble();
+    var top = reader.readDouble();
+    var right = reader.readDouble();
+    var bottom = reader.readDouble();
+    var region = new VidUsRect.tlbr(
+        new VidUsPoint(left, top), new VidUsPoint(right, bottom));
+    return VidUsLogicalCoordinate(
+        isFlipHorizontal, isFlipVertical, region, xUnit, yUnit);
+  }
+}

lib/us/vid_us_mode.dart

@@ -0,0 +1,48 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+
+enum VidUsModeType {
+  Undefined,
+
+  Tissue,
+
+  Flow,
+
+  Doppler,
+
+  TissueTM,
+
+  Tissue3D,
+
+  FlowM,
+}
+
+class VidUsMode {
+  String _name, _displayName;
+  VidUsModeType _type;
+
+  String get name => _name;
+
+  String get displayName => _displayName;
+
+  VidUsModeType get type => _type;
+
+  VidUsMode(this._name, this._displayName, this._type);
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeString(this.name);
+    writer.writeString(this.displayName);
+    writer.writeByte(this._type.index);
+    return writer.data;
+  }
+
+  static VidUsMode fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var name = reader.readString();
+    var displayName = reader.readString();
+    var type = VidUsModeType.values[reader.readByte()];
+    return new VidUsMode(name, displayName, type);
+  }
+}

lib/us/vid_us_physical_coordinate.dart

@@ -0,0 +1,407 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+
+enum PhysicalCoordinateType {
+  Tissue,
+  TimeMotion,
+  ConvexTissue,
+  LinearTissue,
+  ConvexTVTissue,
+  LinearTVTissue,
+  Doppler,
+  TissueTimeMotion,
+  MAM,
+  PWV
+}
+
+class VidUsPhysicalCoordinate {
+  late PhysicalCoordinateType _type;
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeByte(_type.index);
+    return writer.data;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    switch (type) {
+      case PhysicalCoordinateType.ConvexTissue:
+        return VidUsConvexTissuePhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.LinearTissue:
+        return VidUsLinearTissuePhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.ConvexTVTissue:
+        return VidUsConvexTVTissuePhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.LinearTVTissue:
+        return VidUsLinearTVTissuePhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.Doppler:
+        return VidUsDopplerPhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.TissueTimeMotion:
+        return VidUsTissueTimeMotionPhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.MAM:
+        return VidUsMAMPhysicalCoordinate.fromBytes(bytes);
+      case PhysicalCoordinateType.PWV:
+        return VidUsPWVPhysicalCoordinate.fromBytes(bytes);
+      default:
+        throw new Exception("Not supported CoordinateType $type");
+    }
+  }
+}
+
+class VidUsTissuePhysicalCoordinate extends VidUsPhysicalCoordinate {
+  late double _depthEnd;
+
+  late double _depthStart;
+
+  late double _width;
+
+  late double _beamPosition;
+
+  double get depthEnd => _depthEnd;
+
+  double get depthStart => _depthStart;
+
+  double get width => _width;
+
+  double get beamPosition => _beamPosition;
+
+  VidUsTissuePhysicalCoordinate(
+      double depthEnd, double depthStart, double width, double beamPosition) {
+    _type = PhysicalCoordinateType.Tissue;
+    _beamPosition = beamPosition;
+    _width = width;
+    _depthStart = depthStart;
+    _depthEnd = depthEnd;
+  }
+
+  @override
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_depthStart);
+    writer.writeDouble(_depthEnd);
+    writer.writeDouble(_width);
+    writer.writeDouble(_beamPosition);
+    return writer.data;
+  }
+}
+
+class VidUsTimeMotionPhysicalCoordinate extends VidUsPhysicalCoordinate {
+  late double _sweepSpeed;
+
+  late double _max;
+
+  late double _min;
+
+  double get sweepSpeed => _sweepSpeed;
+
+  double get max => _max;
+
+  double get min => _min;
+
+  VidUsTimeMotionPhysicalCoordinate(double sweepSpeed, double max, double min) {
+    _type = PhysicalCoordinateType.TimeMotion;
+    _min = min;
+    _max = max;
+    _sweepSpeed = sweepSpeed;
+  }
+
+  @override
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_min);
+    writer.writeDouble(_max);
+    writer.writeDouble(_sweepSpeed);
+    return writer.data;
+  }
+}
+
+class VidUsConvexTissuePhysicalCoordinate
+    extends VidUsTissuePhysicalCoordinate {
+  late double _zeroRadius;
+  double get zeroRadius => _zeroRadius;
+
+  VidUsConvexTissuePhysicalCoordinate(double depthEnd, double depthStart,
+      double width, double beamPosition, double zeroRadius)
+      : super(depthEnd, depthStart, width, beamPosition) {
+    _type = PhysicalCoordinateType.ConvexTissue;
+    _zeroRadius = zeroRadius;
+  }
+
+  @override
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_zeroRadius);
+    return writer.data;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.ConvexTissue) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.ConvexTissue)}, source type:{$type}");
+    }
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    var width = reader.readDouble();
+    var beamPosition = reader.readDouble();
+    var zeroRadius = reader.readDouble();
+    return new VidUsConvexTissuePhysicalCoordinate(
+        depthEnd, depthStart, width, beamPosition, zeroRadius);
+  }
+}
+
+class VidUsLinearTissuePhysicalCoordinate
+    extends VidUsTissuePhysicalCoordinate {
+  late double _steer;
+
+  double get steer => _steer;
+
+  VidUsLinearTissuePhysicalCoordinate(double depthEnd, double depthStart,
+      double width, double beamPosition, double steer)
+      : super(depthEnd, depthStart, width, beamPosition) {
+    _type = PhysicalCoordinateType.LinearTissue;
+    _steer = steer;
+  }
+
+  @override
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_steer);
+    return writer.data;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.LinearTissue) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.LinearTissue}, source type:{$type}");
+    }
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    var width = reader.readDouble();
+    var beamPosition = reader.readDouble();
+    var steer = reader.readDouble();
+    return new VidUsLinearTissuePhysicalCoordinate(
+        depthEnd, depthStart, width, beamPosition, steer);
+  }
+}
+
+class VidUsConvexTVTissuePhysicalCoordinate
+    extends VidUsConvexTissuePhysicalCoordinate {
+  late double _originalRocx;
+  late double _originalZeroRadius;
+
+  double get originalZeroRadius => _originalZeroRadius;
+
+  double get originalRocx => _originalRocx;
+
+  VidUsConvexTVTissuePhysicalCoordinate(
+      double depthEnd,
+      double depthStart,
+      double width,
+      double beamPosition,
+      double zeroRadius,
+      double originalZeroRadius,
+      double originalRocx)
+      : super(depthEnd, depthStart, width, beamPosition, zeroRadius) {
+    _type = PhysicalCoordinateType.ConvexTVTissue;
+    _originalRocx = originalRocx;
+    _originalZeroRadius = originalZeroRadius;
+  }
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_originalZeroRadius);
+    writer.writeDouble(_originalRocx);
+    return writer.data;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.ConvexTVTissue) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.ConvexTVTissue}, source type:{$type}");
+    }
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    var width = reader.readDouble();
+    var beamPosition = reader.readDouble();
+    var zeroRadius = reader.readDouble();
+    var originalZeroRadius = reader.readDouble();
+    var originalRocx = reader.readDouble();
+    return new VidUsConvexTVTissuePhysicalCoordinate(depthEnd, depthStart,
+        width, beamPosition, zeroRadius, originalZeroRadius, originalRocx);
+  }
+}
+
+class VidUsLinearTVTissuePhysicalCoordinate
+    extends VidUsConvexTissuePhysicalCoordinate {
+  VidUsLinearTVTissuePhysicalCoordinate(double depthEnd, double depthStart,
+      double width, double beamPosition, double zeroRadius)
+      : super(depthEnd, depthStart, width, beamPosition, zeroRadius) {
+    _type = PhysicalCoordinateType.LinearTVTissue;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.LinearTVTissue) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.LinearTVTissue}, source type:{$type}");
+    }
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    var width = reader.readDouble();
+    var beamPosition = reader.readDouble();
+    var zeroRadius = reader.readDouble();
+    return new VidUsLinearTVTissuePhysicalCoordinate(
+        depthEnd, depthStart, width, beamPosition, zeroRadius);
+  }
+}
+
+class VidUsDopplerPhysicalCoordinate extends VidUsTimeMotionPhysicalCoordinate {
+  late double _baseLine;
+
+  double get baseLine => _baseLine;
+
+  VidUsDopplerPhysicalCoordinate(
+      double sweepSpeed, double max, double min, double baseLine)
+      : super(sweepSpeed, max, min) {
+    _type = PhysicalCoordinateType.Doppler;
+    _baseLine = baseLine;
+  }
+
+  @override
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_baseLine);
+    return writer.data;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.Doppler) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.Doppler}, source type:{$type}");
+    }
+    var min = reader.readDouble();
+    var max = reader.readDouble();
+    var sweepSpeed = reader.readDouble();
+    var baseLine = reader.readDouble();
+    return new VidUsDopplerPhysicalCoordinate(sweepSpeed, max, min, baseLine);
+  }
+}
+
+class VidUsTissueTimeMotionPhysicalCoordinate
+    extends VidUsTimeMotionPhysicalCoordinate {
+  late double _depthStart;
+
+  late double _depthEnd;
+
+  double get depthStart => _depthStart;
+
+  double get depthEnd => _depthEnd;
+
+  VidUsTissueTimeMotionPhysicalCoordinate(double sweepSpeed, double max,
+      double min, double depthStart, double depthEnd)
+      : super(sweepSpeed, max, min) {
+    _type = PhysicalCoordinateType.TissueTimeMotion;
+    _depthEnd = depthEnd;
+    _depthStart = depthStart;
+  }
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    var baseData = super.toBytes();
+    writer.writeBytes(baseData);
+    writer.writeDouble(_depthStart);
+    writer.writeDouble(_depthEnd);
+    return writer.data;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.TissueTimeMotion) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.TissueTimeMotion}, source type:{$type}");
+    }
+    var min = reader.readDouble();
+    var max = reader.readDouble();
+    var sweepSpeed = reader.readDouble();
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    return new VidUsTissueTimeMotionPhysicalCoordinate(
+        sweepSpeed, max, min, depthStart, depthEnd);
+  }
+}
+
+class VidUsMAMPhysicalCoordinate
+    extends VidUsTissueTimeMotionPhysicalCoordinate {
+  VidUsMAMPhysicalCoordinate(double sweepSpeed, double max, double min,
+      double depthStart, double depthEnd)
+      : super(sweepSpeed, max, min, depthStart, depthEnd) {
+    _type = PhysicalCoordinateType.MAM;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.MAM) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.MAM}, source type:{$type}");
+    }
+
+    var min = reader.readDouble();
+    var max = reader.readDouble();
+    var sweepSpeed = reader.readDouble();
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    return new VidUsMAMPhysicalCoordinate(
+        sweepSpeed, max, min, depthStart, depthEnd);
+  }
+}
+
+class VidUsPWVPhysicalCoordinate
+    extends VidUsTissueTimeMotionPhysicalCoordinate {
+  VidUsPWVPhysicalCoordinate(double sweepSpeed, double max, double min,
+      double depthStart, double depthEnd)
+      : super(sweepSpeed, max, min, depthStart, depthEnd) {
+    _type = PhysicalCoordinateType.PWV;
+  }
+
+  static VidUsPhysicalCoordinate fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var type = PhysicalCoordinateType.values[reader.readByte()];
+    if (type != PhysicalCoordinateType.PWV) {
+      throw new Exception(
+          "Type not matched, target type:{$PhysicalCoordinateType.PWV}, source type:{$type}");
+    }
+
+    var min = reader.readDouble();
+    var max = reader.readDouble();
+    var sweepSpeed = reader.readDouble();
+    var depthStart = reader.readDouble();
+    var depthEnd = reader.readDouble();
+    return new VidUsPWVPhysicalCoordinate(
+        sweepSpeed, max, min, depthStart, depthEnd);
+  }
+}

lib/us/vid_us_point.dart

@@ -0,0 +1,24 @@
+class VidUsPoint {
+  double _x;
+
+  double _y;
+
+  double get x => _x;
+
+  double get y => _y;
+
+  VidUsPoint(this._x, this._y);
+
+  bool operator ==(other) {
+    if (other is VidUsPoint &&
+        runtimeType == other.runtimeType &&
+        _x == other._x &&
+        _y == other._y) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode => _x.hashCode ^ _y.hashCode;
+}

lib/us/vid_us_probe.dart

@@ -0,0 +1,56 @@
+import 'dart:typed_data';
+
+import 'package:vid/us/vid_us_application.dart';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+
+enum VidUsProbeType {
+  Undefined,
+  Linear,
+  Convex,
+  Sector,
+}
+
+class VidUsProbe {
+  late String _name;
+
+  late VidUsProbeType _type;
+
+  late VidUsApplication _application;
+
+  late double _frameRate;
+
+  String get name => _name;
+
+  VidUsProbeType get type => _type;
+
+  VidUsApplication get application => _application;
+
+  double get frameRate => _frameRate;
+
+  VidUsProbe(String name, VidUsProbeType type, VidUsApplication application,
+      double frameRate) {
+    _name = name;
+    _type = type;
+    _application = application;
+    _frameRate = frameRate;
+  }
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeString(_name);
+    writer.writeByte(_type.index);
+    writer.writeBytes(_application.toBytes());
+    writer.writeDouble(_frameRate);
+    return writer.data;
+  }
+
+  static VidUsProbe fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+    var name = reader.readString();
+    var type = VidUsProbeType.values[reader.readByte()];
+    var application = VidUsApplication.fromBytes(reader.readBytes());
+    var frameRate = reader.readDouble();
+    return new VidUsProbe(name, type, application, frameRate);
+  }
+}

lib/us/vid_us_rect.dart

@@ -0,0 +1,61 @@
+import 'package:vid/us/vid_us_point.dart';
+
+class VidUsRect {
+  late double _left;
+
+  late double _right;
+
+  late double _top;
+
+  late double _bottom;
+
+  double get left => _left;
+
+  double get right => _right;
+
+  double get top => _top;
+
+  double get bottom => _bottom;
+
+  double get width => (_right - _left).abs();
+
+  double get height => (_bottom - _top).abs();
+
+  VidUsPoint get topLeft => new VidUsPoint(_left, _top);
+
+  VidUsPoint get topRight => new VidUsPoint(_right, _top);
+
+  VidUsPoint get bottomLeft => new VidUsPoint(_left, _bottom);
+
+  VidUsPoint get bottomRight => new VidUsPoint(_right, _bottom);
+
+  VidUsRect.xywh(double x, double y, double width, double height) {
+    _left = topLeft.x;
+    _top = topLeft.y;
+    _right = _left + width;
+    _bottom = _top + height;
+  }
+
+  VidUsRect.tlbr(VidUsPoint topLeft, VidUsPoint bottomRight) {
+    _left = topLeft.x;
+    _top = topLeft.y;
+    _right = bottomRight.x;
+    _bottom = bottomRight.y;
+  }
+
+  bool operator ==(other) {
+    if (other is VidUsRect &&
+        runtimeType == other.runtimeType &&
+        _left == other._left &&
+        _right == other._right &&
+        _top == other._top &&
+        _bottom == other._bottom) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode =>
+      _left.hashCode ^ _right.hashCode ^ _top.hashCode ^ _bottom.hashCode;
+}

lib/us/vid_us_tissue_3d_area.dart

@@ -0,0 +1,62 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+import 'package:vid/us/vid_us_point.dart';
+import 'package:vid/us/vid_us_rect.dart';
+
+enum VidUs3DAreaIndicator { Global, A, B, C, ThreeD }
+
+class VidUsTissue3DArea {
+  late VidUsRect _bounds;
+
+  late double _cmPerPixel;
+
+  late VidUsPoint _globalOffset;
+
+  late VidUs3DAreaIndicator _indicator;
+
+  VidUsRect get bounds => _bounds;
+
+  double get cmPerPixel => _cmPerPixel;
+
+  VidUsPoint get globalOffset => _globalOffset;
+
+  VidUs3DAreaIndicator get indicator => _indicator;
+
+  VidUsTissue3DArea(VidUsRect bounds, double cmPerPixel,
+      VidUsPoint globalOffset, VidUs3DAreaIndicator indicator) {
+    _indicator = indicator;
+    _globalOffset = globalOffset;
+    _cmPerPixel = cmPerPixel;
+    _bounds = bounds;
+  }
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeByte(_indicator.index);
+    writer.writeDouble(_cmPerPixel);
+    writer.writeDouble(_globalOffset.x);
+    writer.writeDouble(_globalOffset.y);
+    writer.writeDouble(_bounds.left);
+    writer.writeDouble(_bounds.top);
+    writer.writeDouble(_bounds.right);
+    writer.writeDouble(_bounds.bottom);
+    return writer.data;
+  }
+
+  static VidUsTissue3DArea fromBytes(Uint8List tissue3DAreaData) {
+    var reader = new VidUsDataReader(tissue3DAreaData);
+    var indicator = VidUs3DAreaIndicator.values[reader.readByte()];
+    var cmPerPixel = reader.readDouble();
+    var x = reader.readDouble();
+    var y = reader.readDouble();
+    var globalOffset = new VidUsPoint(x, y);
+    var left = reader.readDouble();
+    var top = reader.readDouble();
+    var right = reader.readDouble();
+    var bottom = reader.readDouble();
+    var bounds = new VidUsRect.tlbr(
+        new VidUsPoint(left, top), new VidUsPoint(right, bottom));
+    return new VidUsTissue3DArea(bounds, cmPerPixel, globalOffset, indicator);
+  }
+}

lib/us/vid_us_unit.dart

@@ -0,0 +1,347 @@
+enum VidUsUnit {
+  None,
+  percent,
+  cm,
+  mm,
+  inch,
+  ft,
+  s,
+  minute,
+  hour,
+  day,
+  week,
+  week_day,
+  Tick,
+  msec,
+  degree,
+  radian,
+  g,
+  mg,
+  ng,
+  kg,
+  oz,
+  lb,
+  cm2,
+  mm2,
+  m2,
+  cm3,
+  mm3,
+  ml,
+  L,
+  cms,
+  mms,
+  ms,
+  cms2,
+  mms2,
+  cm3s,
+  mls,
+  mlmin,
+  Lmin,
+  gcm3,
+  gml,
+  ngml,
+  mmHg,
+
+  mV,
+  Hz,
+  KHz,
+
+  /// <summary>
+  ///  beats per minute
+  /// </summary>
+  HR,
+
+  //SI
+  cm3m2,
+  mlm2,
+
+  //CI
+  cm3sm2,
+  mlsm2,
+  cm3minm2,
+  mlminm2,
+  Lminm2,
+
+  /// <summary>
+  /// MVCF:mean velocity of circumferential fiber shortening
+  /// </summary>
+  circs,
+
+  //CO
+  mlbeat,
+
+  mm2pa,
+
+  d1mpa,
+
+  kpa,
+
+  mmHgs,
+
+  gm2,
+
+  /// AVA Index
+  cm2m2
+}
+
+class VidUsUnitMap {
+  //将单位值转换为单位
+  static VidUsUnit getUnit(int unitValue) {
+    switch (unitValue) {
+      case 0:
+        return VidUsUnit.None;
+      case 1:
+        return VidUsUnit.percent;
+      case 10:
+        return VidUsUnit.cm;
+      case 11:
+        return VidUsUnit.mm;
+      case 12:
+        return VidUsUnit.inch;
+      case 13:
+        return VidUsUnit.ft;
+      case 20:
+        return VidUsUnit.s;
+      case 21:
+        return VidUsUnit.minute;
+      case 22:
+        return VidUsUnit.hour;
+      case 23:
+        return VidUsUnit.day;
+      case 24:
+        return VidUsUnit.week;
+      case 25:
+        return VidUsUnit.week_day;
+      case 26:
+        return VidUsUnit.Tick;
+      case 27:
+        return VidUsUnit.msec;
+      case 30:
+        return VidUsUnit.degree;
+      case 31:
+        return VidUsUnit.radian;
+      case 40:
+        return VidUsUnit.g;
+      case 41:
+        return VidUsUnit.mg;
+      case 42:
+        return VidUsUnit.ng;
+      case 43:
+        return VidUsUnit.kg;
+      case 44:
+        return VidUsUnit.oz;
+      case 45:
+        return VidUsUnit.lb;
+      case 50:
+        return VidUsUnit.cm2;
+      case 51:
+        return VidUsUnit.mm2;
+      case 52:
+        return VidUsUnit.m2;
+      case 60:
+        return VidUsUnit.cm3;
+      case 61:
+        return VidUsUnit.mm3;
+      case 62:
+        return VidUsUnit.ml;
+      case 63:
+        return VidUsUnit.L;
+      case 70:
+        return VidUsUnit.cms;
+      case 71:
+        return VidUsUnit.mms;
+      case 72:
+        return VidUsUnit.ms;
+      case 80:
+        return VidUsUnit.cms2;
+      case 81:
+        return VidUsUnit.mms2;
+      case 90:
+        return VidUsUnit.cm3s;
+      case 91:
+        return VidUsUnit.mls;
+      case 92:
+        return VidUsUnit.mlmin;
+      case 93:
+        return VidUsUnit.Lmin;
+      case 100:
+        return VidUsUnit.gcm3;
+      case 101:
+        return VidUsUnit.gml;
+      case 102:
+        return VidUsUnit.ngml;
+      case 110:
+        return VidUsUnit.mmHg;
+      case 120:
+        return VidUsUnit.mV;
+      case 130:
+        return VidUsUnit.Hz;
+      case 131:
+        return VidUsUnit.KHz;
+      case 132:
+        return VidUsUnit.HR;
+      case 140:
+        return VidUsUnit.cm3m2;
+      case 141:
+        return VidUsUnit.mlm2;
+      case 150:
+        return VidUsUnit.cm3sm2;
+      case 151:
+        return VidUsUnit.mlsm2;
+      case 153:
+        return VidUsUnit.cm3minm2;
+      case 154:
+        return VidUsUnit.mlminm2;
+      case 155:
+        return VidUsUnit.Lminm2;
+      case 160:
+        return VidUsUnit.circs;
+      case 170:
+        return VidUsUnit.mlbeat;
+      case 180:
+        return VidUsUnit.mm2pa;
+      case 181:
+        return VidUsUnit.d1mpa;
+      case 182:
+        return VidUsUnit.kpa;
+      case 190:
+        return VidUsUnit.mmHgs;
+      case 200:
+        return VidUsUnit.gm2;
+      case 210:
+        return VidUsUnit.cm2m2;
+      default:
+        throw new FormatException('Not supported unit value $unitValue}');
+    }
+  }
+
+  //将单位转换为单位值
+  static int getUnitValue(VidUsUnit unit) {
+    switch (unit) {
+      case VidUsUnit.None:
+        return 0;
+      case VidUsUnit.percent:
+        return 1;
+      case VidUsUnit.cm:
+        return 10;
+      case VidUsUnit.mm:
+        return 11;
+      case VidUsUnit.inch:
+        return 12;
+      case VidUsUnit.ft:
+        return 13;
+      case VidUsUnit.s:
+        return 20;
+      case VidUsUnit.minute:
+        return 21;
+      case VidUsUnit.hour:
+        return 22;
+      case VidUsUnit.day:
+        return 23;
+      case VidUsUnit.week:
+        return 24;
+      case VidUsUnit.week_day:
+        return 25;
+      case VidUsUnit.Tick:
+        return 26;
+      case VidUsUnit.msec:
+        return 27;
+      case VidUsUnit.degree:
+        return 30;
+      case VidUsUnit.radian:
+        return 31;
+      case VidUsUnit.g:
+        return 40;
+      case VidUsUnit.mg:
+        return 41;
+      case VidUsUnit.ng:
+        return 42;
+      case VidUsUnit.kg:
+        return 43;
+      case VidUsUnit.oz:
+        return 44;
+      case VidUsUnit.lb:
+        return 45;
+      case VidUsUnit.cm2:
+        return 50;
+      case VidUsUnit.mm2:
+        return 51;
+      case VidUsUnit.m2:
+        return 52;
+      case VidUsUnit.cm3:
+        return 60;
+      case VidUsUnit.mm3:
+        return 61;
+      case VidUsUnit.ml:
+        return 62;
+      case VidUsUnit.L:
+        return 63;
+      case VidUsUnit.cms:
+        return 70;
+      case VidUsUnit.mms:
+        return 71;
+      case VidUsUnit.ms:
+        return 72;
+      case VidUsUnit.cms2:
+        return 80;
+      case VidUsUnit.mms2:
+        return 81;
+      case VidUsUnit.cm3s:
+        return 90;
+      case VidUsUnit.mls:
+        return 91;
+      case VidUsUnit.mlmin:
+        return 92;
+      case VidUsUnit.Lmin:
+        return 93;
+      case VidUsUnit.gcm3:
+        return 100;
+      case VidUsUnit.gml:
+        return 101;
+      case VidUsUnit.ngml:
+        return 102;
+      case VidUsUnit.mmHg:
+        return 110;
+      case VidUsUnit.mV:
+        return 120;
+      case VidUsUnit.Hz:
+        return 130;
+      case VidUsUnit.KHz:
+        return 131;
+      case VidUsUnit.HR:
+        return 132;
+      case VidUsUnit.cm3m2:
+        return 140;
+      case VidUsUnit.mlm2:
+        return 141;
+      case VidUsUnit.cm3sm2:
+        return 150;
+      case VidUsUnit.mlsm2:
+        return 151;
+      case VidUsUnit.cm3minm2:
+        return 153;
+      case VidUsUnit.mlminm2:
+        return 154;
+      case VidUsUnit.Lminm2:
+        return 155;
+      case VidUsUnit.circs:
+        return 160;
+      case VidUsUnit.mlbeat:
+        return 170;
+      case VidUsUnit.mm2pa:
+        return 180;
+      case VidUsUnit.d1mpa:
+        return 181;
+      case VidUsUnit.kpa:
+        return 182;
+      case VidUsUnit.mmHgs:
+        return 190;
+      case VidUsUnit.gm2:
+        return 200;
+      case VidUsUnit.cm2m2:
+        return 210;
+      default:
+        throw new FormatException('Not supported unit $unit}');
+    }
+  }
+}

lib/us/vid_us_visual.dart

@@ -0,0 +1,83 @@
+import 'dart:typed_data';
+import 'package:vid/us/vid_us_2d_visual.dart';
+import 'package:vid/us/vid_us_3d_visual.dart';
+import 'package:vid/us/vid_us_data_reader.dart';
+import 'package:vid/us/vid_us_data_writer.dart';
+import 'package:vid/us/vid_us_display_mode.dart';
+import 'package:vid/us/vid_us_mode.dart';
+import 'package:vid/us/vid_us_visual_indicator.dart';
+import 'package:vid/us/vid_us_visual_type.dart';
+
+class VidUsVisual {
+  late VidUsDisplayMode _displayMode;
+  late VidUsModeType _activeModeType;
+  late VidUsVisualIndicator _indicator;
+  late VidUsVisualType _visualType;
+  late List<VidUsMode> _modes;
+
+  /// Gets or sets the Display mode of this image.
+  VidUsDisplayMode get displayMode => _displayMode;
+
+  /// Gets the visual type of this Visual.
+  VidUsVisualType get visualType => _visualType;
+
+  /// Gets or sets the Indicator of this Visual.
+  VidUsVisualIndicator get indicator => _indicator;
+
+  /// Gets or set the active mode type of this visual.
+  VidUsModeType get activeModeType => _activeModeType;
+
+  /// Gets all modse of this visual.
+  List<VidUsMode> get modes => _modes;
+
+  VidUsVisual() {
+    _activeModeType = VidUsModeType.Undefined;
+    _modes = [];
+    //Default is A
+    _indicator = VidUsVisualIndicator.A;
+    //Default is Normal
+    _displayMode = VidUsDisplayMode.Normal;
+  }
+
+  void setVisualType(VidUsVisualType type) {
+    _visualType = type;
+  }
+
+  void setIndicator(VidUsVisualIndicator indicator) {
+    _indicator = indicator;
+  }
+
+  void setActiveModeType(VidUsModeType type) {
+    _activeModeType = type;
+  }
+
+  void setDisplayMode(VidUsDisplayMode mode) {
+    _displayMode = mode;
+  }
+
+  Uint8List toBytes() {
+    var writer = new VidUsDataWriter();
+    writer.writeByte(_visualType.index);
+    writer.writeByte(_displayMode.index);
+    writer.writeByte(_indicator.index);
+    writer.writeByte(_activeModeType.index);
+    writer.writeByte(_modes.length);
+    _modes.forEach((mode) {
+      writer.writeBytes(mode.toBytes());
+    });
+    return writer.data;
+  }
+
+  static VidUsVisual fromBytes(Uint8List bytes) {
+    var reader = new VidUsDataReader(bytes);
+
+    var visualType = VidUsVisualType.values[reader.readByte()];
+    if (visualType == VidUsVisualType.V2D) {
+      return VidUs2DVisual.fromBytes(bytes);
+    }
+    if (visualType == VidUsVisualType.V3D) {
+      return VidUs3DVisual.fromBytes(bytes);
+    }
+    throw new Exception("Not supported visual $visualType");
+  }
+}

lib/us/vid_us_visual_area_type.dart

@@ -0,0 +1,25 @@
+enum VidUsVisualAreaType {
+  Tissue,
+
+  Flow,
+
+  TimeMotion,
+
+  Doppler,
+
+  TissueTimeMotion,
+
+  Trace,
+
+  Colorbar,
+
+  Tissue3D,
+
+  ZoomTissue,
+
+  ZoomFlow,
+
+  AssociateTissue,
+
+  AssociateFlow,
+}

lib/us/vid_us_visual_indicator.dart

@@ -0,0 +1 @@
+enum VidUsVisualIndicator { A, B, C, D }

lib/us/vid_us_visual_type.dart

@@ -0,0 +1,4 @@
+enum VidUsVisualType {
+  V2D,
+  V3D,
+}

pubspec.yaml

@@ -0,0 +1,53 @@
+name: vid
+description: vid data reader/writer for flutter.
+version: 0.0.1
+homepage:
+
+environment:
+  sdk: ">=2.12.0 <3.0.0"
+  flutter: ">=1.17.0"
+
+dependencies:
+  flutter:
+    sdk: flutter
+
+dev_dependencies:
+  flutter_test:
+    sdk: flutter
+
+# For information on the generic Dart part of this file, see the
+# following page: https://dart.dev/tools/pub/pubspec
+
+# The following section is specific to Flutter.
+flutter:
+
+  # To add assets to your package, add an assets section, like this:
+  # assets:
+  #   - images/a_dot_burr.jpeg
+  #   - images/a_dot_ham.jpeg
+  #
+  # For details regarding assets in packages, see
+  # https://flutter.dev/assets-and-images/#from-packages
+  #
+  # An image asset can refer to one or more resolution-specific "variants", see
+  # https://flutter.dev/assets-and-images/#resolution-aware.
+
+  # To add custom fonts to your package, add a fonts section here,
+  # in this "flutter" section. Each entry in this list should have a
+  # "family" key with the font family name, and a "fonts" key with a
+  # list giving the asset and other descriptors for the font. For
+  # example:
+  # fonts:
+  #   - family: Schyler
+  #     fonts:
+  #       - asset: fonts/Schyler-Regular.ttf
+  #       - asset: fonts/Schyler-Italic.ttf
+  #         style: italic
+  #   - family: Trajan Pro
+  #     fonts:
+  #       - asset: fonts/TrajanPro.ttf
+  #       - asset: fonts/TrajanPro_Bold.ttf
+  #         weight: 700
+  #
+  # For details regarding fonts in packages, see
+  # https://flutter.dev/custom-fonts/#from-packages