Merge branch 'dev'

* dev:
  update build bat for 2022
  e57: fix cached colors, Update nuget package licences list
  add initial E57 support

# Conflicts:
#	MainWindow.xaml.cs

#BUILD

Author: unitycoder

Build.cmd

@@ -4,7 +4,8 @@ if exist Debug rd /s /q Debug
 if exist Release rd /s /q Release
 if exist x64 rd /s /q x64
 
-"%programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\MSBuild\Current\Bin\msbuild.exe" /p:Configuration=Release
+"%programfiles%\Microsoft Visual Studio\2022\Enterprise\MSBuild\Current\Bin\msbuild.exe" /p:Configuration=Release
+REM "%programfiles%\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\msbuild.exe" /p:Configuration=Release
 
 :exit
 popd

LICENSE

@@ -34,6 +34,8 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Aardvark.Base" Version="5.3.12" />
+    <PackageReference Include="Aardvark.Data.E57" Version="5.5.6" />
     <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Ply.Net" Version="5.5.5" />

PointCloudConverter.csproj

@@ -0,0 +1,193 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Aardvark.Base;
+using Aardvark.Data.Points.Import;
+using PointCloudConverter.Structs;
+using static Aardvark.Data.Points.Import.E57;
+using Aardvark.Data.Points;
+using System.Text.Json;
+using Aardvark.Data.E57;
+
+namespace PointCloudConverter.Readers
+{
+    public class E57 : IReader, IDisposable
+    {
+        private IEnumerator<E57Chunk> chunkEnumerator;
+        private E57Chunk currentChunk;
+        private int currentPointIndex = 0;
+
+        private ASTM_E57.E57FileHeader header;
+        private E57MetaData metaData;
+
+        private Float3 lastXYZ;
+
+        public struct E57MetaData
+        {
+            public string Name { get; set; }
+            public double X { get; set; }
+            public double Y { get; set; }
+            public double Z { get; set; }
+            public double RX { get; set; }
+            public double RY { get; set; }
+            public double RZ { get; set; }
+            public double RW { get; set; }
+        }
+
+        public bool InitReader(ImportSettings importSettings, int fileIndex)
+        {
+            try
+            {
+                var filePath = importSettings.inputFiles[fileIndex];
+
+                // Read header metadata
+                using var stream = File.OpenRead(filePath);
+                header = ASTM_E57.E57FileHeader.Parse(stream, new FileInfo(filePath).Length, false);
+                stream.Close();
+
+                var pose = header.E57Root.Data3D[0].Pose;
+
+                metaData = new E57MetaData
+                {
+                    Name = header.E57Root.Data3D[0].Name,
+                    X = pose.Translation.X,
+                    Y = importSettings.swapYZ ? pose.Translation.Z : pose.Translation.Y,
+                    Z = importSettings.swapYZ ? pose.Translation.Y : pose.Translation.Z,
+                    RX = pose.Rotation.X,
+                    RY = importSettings.swapYZ ? pose.Rotation.Z : pose.Rotation.Y,
+                    RZ = importSettings.swapYZ ? pose.Rotation.Y : pose.Rotation.Z,
+                    RW = pose.Rotation.W
+                };
+
+                var chunks = ChunksFull(filePath, ParseConfig.Default);
+                chunkEnumerator = chunks.GetEnumerator();
+
+                if (!chunkEnumerator.MoveNext())
+                    return false;
+
+                currentChunk = chunkEnumerator.Current;
+                currentPointIndex = 0;
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("E57 InitReader error: " + ex.Message);
+                return false;
+            }
+        }
+
+        public LasHeader GetMetaData(ImportSettings importSettings, int fileIndex)
+        {
+            return new LasHeader
+            {
+                FileName = importSettings.inputFiles[fileIndex],
+                NumberOfPointRecords = (uint)(header?.E57Root?.Data3D?[0]?.Points?.RecordCount ?? 0)
+            };
+        }
+
+        public Bounds GetBounds()
+        {
+            var bounds = header.E57Root.Data3D[0].CartesianBounds.Bounds;
+
+            return new Bounds
+            {
+                minX = (float)bounds.X.Min,
+                maxX = (float)bounds.X.Max,
+                minY = (float)bounds.Y.Min,
+                maxY = (float)bounds.Y.Max,
+                minZ = (float)bounds.Z.Min,
+                maxZ = (float)bounds.Z.Max
+            };
+        }
+
+        public int GetPointCount()
+        {
+            return (int)(header?.E57Root?.Data3D?[0]?.Points?.RecordCount ?? 0);
+        }
+
+        public Float3 GetXYZ()
+        {
+            if (currentChunk == null || currentPointIndex >= currentChunk.Count)
+            {
+                if (!chunkEnumerator.MoveNext())
+                    return new Float3 { hasError = true };
+
+                currentChunk = chunkEnumerator.Current;
+                currentPointIndex = 0;
+
+                // clear cachedColors when chunk changes
+                cachedColors = null;
+            }
+
+            var p = currentChunk.Positions[currentPointIndex];
+            lastXYZ.x = p.X;
+            lastXYZ.y = p.Y;
+            lastXYZ.z = p.Z;
+            lastXYZ.hasError = false;
+
+            currentPointIndex++;
+            return lastXYZ;
+        }
+
+        private C3b[] cachedColors = null;
+
+        public Color GetRGB()
+        {
+            if (cachedColors == null && currentChunk?.Colors != null)
+            {
+                cachedColors = currentChunk.Colors;
+            }
+
+            int i = currentPointIndex - 1;
+            if (cachedColors != null && i >= 0 && i < cachedColors.Length)
+            {
+                var c = cachedColors[i];
+                return new Color
+                {
+                    r = c.R / 255f,
+                    g = c.G / 255f,
+                    b = c.B / 255f
+                };
+            }
+
+            return default;
+        }
+
+        public byte GetIntensity()
+        {
+            var i = currentPointIndex - 1;
+            if (currentChunk?.Intensities != null && i >= 0 && i < currentChunk.Intensities.Length)
+            {
+                return (byte)currentChunk.Intensities[i];
+            }
+            return 0;
+        }
+
+        public byte GetClassification() => 0;
+
+        public double GetTime()
+        {
+            // Not implemented for now
+            return 0;
+        }
+
+        public void Close() { }
+
+        public void Dispose()
+        {
+            Close();
+            GC.SuppressFinalize(this);
+        }
+
+        ~E57()
+        {
+            Dispose();
+        }
+
+        public string GetMetaDataJSON()
+        {
+            return JsonSerializer.Serialize(metaData);
+        }
+    }
+}

Readers/E57.cs

@@ -33,6 +33,14 @@ public class PLY : IReader, IDisposable
         //        private byte currentClassification;
         private Bounds bounds;
 
+
+        //int? taskID;
+        //// add constructor
+        //public PLY(int? _taskID)
+        //{
+        //    taskID = _taskID;
+        //}
+
         public bool InitReader(ImportSettings importSettings, int fileIndex)
         {
             var file = importSettings.inputFiles[fileIndex];

Readers/PLY.cs

@@ -4,6 +4,7 @@ public enum ImportFormat
     {
         Unknown,
         LAS, // and LAZ
-        PLY
+        PLY,
+        E57
     }
 }

Structs/ImportFormat.cs

@@ -68,6 +68,9 @@ public IReader GetOrCreateReader(int? taskId)
                     case ImportFormat.PLY:
                         readerInstance = new PLY(); // no taskId needed here
                         break;
+                    case ImportFormat.E57:
+                        readerInstance = new E57();
+                        break;
                     default:
                         Log.Write($"Unsupported import format: {importFormat}", LogEvent.Error);
                         throw new NotSupportedException($"Unsupported import format: {importFormat}");

Structs/ImportSettings.cs

@@ -153,7 +153,7 @@ public static ImportSettings Parse(string[] args, string rootFolder, ILogger log
                                 string importFormatParsed = param.ToUpper();
 
                                 if (string.IsNullOrEmpty(importFormatParsed) ||
-                                    (importFormatParsed != "LAS" && importFormatParsed != "LAZ" && importFormatParsed != "PLY"))
+                                    (importFormatParsed != "LAS" && importFormatParsed != "LAZ" && importFormatParsed != "PLY") && importFormatParsed != "E57")
                                 {
                                     importSettings.errors.Add("Unsupported import format: " + param);
                                     importSettings.importFormat = ImportFormat.Unknown;
@@ -171,6 +171,10 @@ public static ImportSettings Parse(string[] args, string rootFolder, ILogger log
                                             importSettings.importFormat = ImportFormat.PLY;
                                             importSettings.reader = new PLY();
                                             break;
+                                        case "E57":
+                                            importSettings.importFormat = ImportFormat.E57;
+                                            importSettings.reader = new E57();
+                                            break;
                                     }
                                 }
                                 break;