407 lines
20 KiB
C#
407 lines
20 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Printing.IndexedProperties;
|
|
using System.Text;
|
|
using System.Windows.Markup;
|
|
|
|
namespace LASRead.LASFormat
|
|
{
|
|
class LASFormatDetail
|
|
{
|
|
/* Primative Types:
|
|
* (LAS = C#)
|
|
* char = byte
|
|
* uchar = char
|
|
* short = int16
|
|
* ushort = uint16
|
|
* long = int
|
|
* ulong = uint
|
|
* long long = int64
|
|
* ulong long = uint64
|
|
* float = float
|
|
* double = double
|
|
* string = 1-byte, ASCII chars, null terminated unless at max length (therefore no termination)
|
|
*/
|
|
|
|
/* Public header:
|
|
* char[4] - signature
|
|
* ushort - file id
|
|
* ushort encoding
|
|
* ulong ?- guid 1
|
|
* ushort ?- guid 2
|
|
* ushort ?- guid 3
|
|
* uchar[8] ?- guid 4
|
|
* uchar
|
|
*/
|
|
|
|
}
|
|
public class FileHeader
|
|
{
|
|
ushort headerSize;
|
|
// Follows the correct order of the header
|
|
char[] fileSignature;
|
|
ushort fileSourceID;
|
|
ushort globalEncoding;
|
|
// Optional Fields are filled with zero
|
|
uint GUIDData1 = 0;
|
|
ushort GUIDData2 = 0;
|
|
ushort GUIDData3 = 0;
|
|
byte[] GUIDData4 = new byte[] {0,0,0,0,0,0,0,0};
|
|
byte versionMajor;
|
|
byte versionMinor;
|
|
char[] systemIdentifier;
|
|
char[] generatingSoftware;
|
|
ushort fileCreationDayOfYear;
|
|
ushort fileCreationYear;
|
|
uint dataOffset;
|
|
uint numberVLRs; // Variable Length Records
|
|
byte pointDataRecordFormat;
|
|
ushort pointDataRecordLength;
|
|
uint legacyNumberOfPointRecords;
|
|
uint[] legacyNumberOfPointByReturn;
|
|
double x_scaleFactor;
|
|
double y_scaleFactor;
|
|
double z_scaleFactor;
|
|
double x_offset;
|
|
double y_offset;
|
|
double z_offset;
|
|
double x_max;
|
|
double x_min;
|
|
double y_max;
|
|
double y_min;
|
|
double z_max;
|
|
double z_min;
|
|
ulong startOfWaveformDPR; // Data Packet Record
|
|
ulong startOfFirstExtendedVLR;
|
|
uint numberOfExtendedVLRs;
|
|
ulong numberPointRecords;
|
|
ulong[] numberPointsByReturn;
|
|
/// <summary>
|
|
/// Signature of the data. Should always be "LASF"
|
|
/// </summary>
|
|
public char[] FileSignature { get => fileSignature; set => fileSignature = value; }
|
|
/// <summary>
|
|
/// ID Associated with the data. Intended to differentiate between different sources
|
|
/// </summary>
|
|
public ushort FileSourceID { get => fileSourceID; set => fileSourceID = value; }
|
|
/// <summary>
|
|
/// Flags Indicating the formats of certain data <br />
|
|
/// 0 : GPS Time Format (0 - Week time; 1 - standard GPS Time) <br />
|
|
/// 1 : Waveforms included (depricated) <br />
|
|
/// 2 : Waveforms in associated .wdp file (mutex with 1:) <br />
|
|
/// 3 : Point returns are synthetic <br />
|
|
/// 4 : Coordinate Reference System is WKT, else GeoTIFF <br />
|
|
/// 5-15 : Reserved <br />
|
|
/// </summary>
|
|
public ushort GlobalEncoding { get => globalEncoding; set => globalEncoding = value; }
|
|
public uint GUIDData11 { get => GUIDData1; set => GUIDData1 = value; }
|
|
public ushort GUIDData21 { get => GUIDData2; set => GUIDData2 = value; }
|
|
public ushort GUIDData31 { get => GUIDData3; set => GUIDData3 = value; }
|
|
public byte[] GUIDData41 { get => GUIDData4; set => GUIDData4 = value; }
|
|
public byte VersionMajor { get => versionMajor; set => versionMajor = value; }
|
|
public byte VersionMinor { get => versionMinor; set => versionMinor = value; }
|
|
/// <summary>
|
|
/// Identifies the hardware used to collect the data <br />
|
|
/// Can be MERGE, MODIFICATION, EXTRACTION, TRANSFORMATION, OTHER, or a custom expression
|
|
/// </summary>
|
|
public char[] SystemIdentifier { get => systemIdentifier; set => systemIdentifier = value; }
|
|
/// <summary>
|
|
/// Identifies the software used to encode the data
|
|
/// </summary>
|
|
public char[] GeneratingSoftware { get => generatingSoftware; set => generatingSoftware = value; }
|
|
/// <summary>
|
|
/// The day of the year this file was created
|
|
/// </summary>
|
|
public ushort FileCreationDayOfYear { get => fileCreationDayOfYear; set => fileCreationDayOfYear = value; }
|
|
/// <summary>
|
|
/// The year this data was collected
|
|
/// </summary>
|
|
public ushort FileCreationYear { get => fileCreationYear; set => fileCreationYear = value; }
|
|
/// <summary>
|
|
/// The size of this header
|
|
/// </summary>
|
|
public ushort HeaderSize { get => headerSize; set => headerSize = value; }
|
|
/// <summary>
|
|
/// The offset of the first Point-Data-Record (PDR)
|
|
/// </summary>
|
|
public uint DataOffset { get => dataOffset; set => dataOffset = value; }
|
|
/// <summary>
|
|
/// The number of Variable Length Records (VLRs) present
|
|
/// </summary>
|
|
public uint NumberVLRs { get => numberVLRs; set => numberVLRs = value; }
|
|
/// <summary>
|
|
/// An integer representing the format of the PDR data. <br />
|
|
/// See <see cref="IPointDataRecord"/>
|
|
/// </summary>
|
|
public byte PointDataRecordFormat { get => pointDataRecordFormat; set => pointDataRecordFormat = value; }
|
|
/// <summary>
|
|
/// The length of a PDR record
|
|
/// </summary>
|
|
public ushort PointDataRecordLength { get => pointDataRecordLength; set => pointDataRecordLength = value; }
|
|
/// <summary>
|
|
/// Number of point records for legacy compatibility (32 bits)
|
|
/// </summary>
|
|
public uint LegacyNumberOfPointRecords { get => legacyNumberOfPointRecords; set => legacyNumberOfPointRecords = value; }
|
|
/// <summary>
|
|
/// todo
|
|
/// </summary>
|
|
public uint[] LegacyNumberOfPointByReturn { get => legacyNumberOfPointByReturn; set => legacyNumberOfPointByReturn = value; }
|
|
/// <summary>
|
|
/// Scale factor of the X axis. Multiply by this value to get the true value
|
|
/// </summary>
|
|
public double X_scaleFactor { get => x_scaleFactor; set => x_scaleFactor = value; }
|
|
/// <summary>
|
|
/// Scale factor of the Y axis. Multiply by this value to get the true value
|
|
/// </summary>
|
|
public double Y_scaleFactor { get => y_scaleFactor; set => y_scaleFactor = value; }
|
|
/// <summary>
|
|
/// Scale factor of the Z axis. Multiply by this value to get the true value
|
|
/// </summary>
|
|
public double Z_scaleFactor { get => z_scaleFactor; set => z_scaleFactor = value; }
|
|
/// <summary>
|
|
/// Offset of the X axis. <br />
|
|
/// Calculate Coordinates like so: <br />
|
|
/// X_final = X * X_scaleFactor + X_offset
|
|
/// </summary>
|
|
public double X_offset { get => x_offset; set => x_offset = value; }
|
|
/// <summary>
|
|
/// Offset of the Y axis. <br />
|
|
/// Calculate Coordinates like so: <br />
|
|
/// Y_final = Y * Y_scaleFactor + Y_offset
|
|
/// </summary>
|
|
public double Y_offset { get => y_offset; set => y_offset = value; }
|
|
/// <summary>
|
|
/// Offset of the Z axis. <br />
|
|
/// Calculate Coordinates like so: <br />
|
|
/// Z_final = Z * Z_scaleFactor + Z_offset
|
|
/// </summary>
|
|
public double Z_offset { get => z_offset; set => z_offset = value; }
|
|
/// <summary>
|
|
/// Largest X value in the data
|
|
/// </summary>
|
|
public double X_max { get => x_max; set => x_max = value; }
|
|
/// <summary>
|
|
/// Smallest X value in the data
|
|
/// </summary>
|
|
public double X_min { get => x_min; set => x_min = value; }
|
|
/// <summary>
|
|
/// Largest Y value in the data
|
|
/// </summary>
|
|
public double Y_max { get => y_max; set => y_max = value; }
|
|
/// <summary>
|
|
/// Smallest Y value in the data
|
|
/// </summary>
|
|
public double Y_min { get => y_min; set => y_min = value; }
|
|
/// <summary>
|
|
/// Largest Z value in the data
|
|
/// </summary>
|
|
public double Z_max { get => z_max; set => z_max = value; }
|
|
/// <summary>
|
|
/// Smallest Z value in the data
|
|
/// </summary>
|
|
public double Z_min { get => z_min; set => z_min = value; }
|
|
/// <summary>
|
|
/// <b>New in 1.4</b><br />
|
|
/// Start of the Waveform Data Packet Records
|
|
/// </summary>
|
|
public ulong StartOfWaveformDPR { get => startOfWaveformDPR; set => startOfWaveformDPR = value; }
|
|
/// <summary>
|
|
/// <b>New in 1.4</b><br />
|
|
/// Start of the first Extended Variable Length Record (EVLR)
|
|
/// </summary>
|
|
public ulong StartOfFirstExtendedVLR { get => startOfFirstExtendedVLR; set => startOfFirstExtendedVLR = value; }
|
|
/// <summary>
|
|
/// <b>New in 1.4</b><br />
|
|
/// Number of Extended Variable Length Records
|
|
/// </summary>
|
|
public uint NumberOfExtendedVLRs { get => numberOfExtendedVLRs; set => numberOfExtendedVLRs = value; }
|
|
/// <summary>
|
|
/// <b>New in 1.4</b><br />
|
|
/// Number of point records (64 bits)
|
|
/// </summary>
|
|
public ulong NumberPointRecords { get => numberPointRecords; set => numberPointRecords = value; }
|
|
/// <summary>
|
|
/// <b>New in 1.4</b><br />
|
|
/// todo
|
|
/// </summary>
|
|
public ulong[] NumberPointsByReturn { get => numberPointsByReturn; set => numberPointsByReturn = value; }
|
|
|
|
public byte[] GetAsByteArray()
|
|
{
|
|
byte[] endBytes = new byte[headerSize];
|
|
DataHelpers.ToByteArray(fileSignature).CopyTo(endBytes,0); //4
|
|
BitConverter.GetBytes(fileSourceID).CopyTo(endBytes, 4); // 2
|
|
BitConverter.GetBytes(globalEncoding).CopyTo(endBytes, 6); // 2
|
|
BitConverter.GetBytes(GUIDData1).CopyTo(endBytes, 8); // 4
|
|
BitConverter.GetBytes(GUIDData2).CopyTo(endBytes, 12); // 2
|
|
BitConverter.GetBytes(GUIDData3).CopyTo(endBytes, 14); // 2
|
|
GUIDData4.CopyTo(endBytes, 16); // 8
|
|
endBytes[24] = versionMajor;
|
|
endBytes[25] = versionMinor;
|
|
DataHelpers.ToByteArray(systemIdentifier).CopyTo(endBytes, 26); // 32 Bytes
|
|
DataHelpers.ToByteArray(GeneratingSoftware).CopyTo(endBytes, 58); // 32 Bytes
|
|
BitConverter.GetBytes(fileCreationDayOfYear).CopyTo(endBytes, 90); // 2
|
|
BitConverter.GetBytes(fileCreationYear).CopyTo(endBytes, 92); // 2
|
|
BitConverter.GetBytes(headerSize).CopyTo(endBytes, 94); // 2
|
|
BitConverter.GetBytes(dataOffset).CopyTo(endBytes, 96); // 4
|
|
BitConverter.GetBytes(numberVLRs).CopyTo(endBytes, 100); // 4
|
|
endBytes[104] = pointDataRecordFormat;
|
|
BitConverter.GetBytes(pointDataRecordLength).CopyTo(endBytes, 105); // 2
|
|
BitConverter.GetBytes(legacyNumberOfPointRecords).CopyTo(endBytes, 107); // 4
|
|
DataHelpers.ToByteArray(LegacyNumberOfPointByReturn).CopyTo(endBytes, 111); // 20 bytes
|
|
BitConverter.GetBytes(X_scaleFactor).CopyTo(endBytes, 131); // 8
|
|
BitConverter.GetBytes(Y_scaleFactor).CopyTo(endBytes, 139); // 8
|
|
BitConverter.GetBytes(Z_scaleFactor).CopyTo(endBytes, 147); // 8
|
|
BitConverter.GetBytes(X_offset).CopyTo(endBytes, 155); // 8
|
|
BitConverter.GetBytes(Y_offset).CopyTo(endBytes, 163); // 8
|
|
BitConverter.GetBytes(Z_offset).CopyTo(endBytes, 171); // 8
|
|
BitConverter.GetBytes(X_max).CopyTo(endBytes, 179); // 8
|
|
BitConverter.GetBytes(X_min).CopyTo(endBytes, 187); // 8
|
|
BitConverter.GetBytes(Y_max).CopyTo(endBytes, 195); // 8
|
|
BitConverter.GetBytes(Y_min).CopyTo(endBytes, 203); // 8
|
|
BitConverter.GetBytes(Z_max).CopyTo(endBytes, 211); // 8
|
|
BitConverter.GetBytes(Z_min).CopyTo(endBytes, 219); // 8
|
|
if (VersionMajor >= 1 && VersionMinor >= 4)
|
|
{
|
|
BitConverter.GetBytes(startOfWaveformDPR).CopyTo(endBytes, 227); // 8
|
|
BitConverter.GetBytes(StartOfFirstExtendedVLR).CopyTo(endBytes, 235); // 8
|
|
BitConverter.GetBytes(NumberOfExtendedVLRs).CopyTo(endBytes, 243); // 4
|
|
BitConverter.GetBytes(NumberPointRecords).CopyTo(endBytes, 247); // 8
|
|
DataHelpers.ToByteArray(NumberPointsByReturn).CopyTo(endBytes, 255); // 120 Bytes
|
|
}
|
|
return endBytes;
|
|
}
|
|
/// <summary>
|
|
/// Reads the header from the provided source
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <returns>The expected size of the header</returns>
|
|
public bool ReadHeader(Stream source)
|
|
{
|
|
source.Position = 94;
|
|
byte[] headerSizeBytes = new byte[2];
|
|
source.Read(headerSizeBytes, 0, 2);
|
|
headerSize = BitConverter.ToUInt16(headerSizeBytes, 0);
|
|
if (headerSize < 375)
|
|
{
|
|
// Assert the version is less than 1.4, where records after z-min were added.
|
|
source.Position = 24;
|
|
byte major = (byte)source.ReadByte();
|
|
byte minor = (byte)source.ReadByte();
|
|
if (major >= 1 && minor > 3)
|
|
{
|
|
throw new InvalidDataException("Header is too small for data format >= v1.4");
|
|
}
|
|
}
|
|
source.Position = 0;
|
|
|
|
byte[] inputHeader = new byte[headerSize];
|
|
source.Read(inputHeader, 0, HeaderSize);
|
|
|
|
FileSignature = new char[] { (char)inputHeader[0], (char)inputHeader[1], (char)inputHeader[2], (char)inputHeader[3] };
|
|
FileSourceID = BitConverter.ToUInt16(inputHeader, 4);
|
|
GlobalEncoding = BitConverter.ToUInt16(inputHeader, 6);
|
|
GUIDData11 = BitConverter.ToUInt32(inputHeader, 8);
|
|
GUIDData21 = BitConverter.ToUInt16(inputHeader, 12);
|
|
GUIDData31 = BitConverter.ToUInt16(inputHeader, 14);
|
|
GUIDData41 = new byte[] { inputHeader[16], inputHeader[17], inputHeader[18], inputHeader[19], inputHeader[20], inputHeader[21], inputHeader[22], inputHeader[23]};
|
|
VersionMajor = inputHeader[24];
|
|
VersionMinor = inputHeader[25];
|
|
SystemIdentifier = DataHelpers.ToCharArray(inputHeader, 26, 32);
|
|
GeneratingSoftware = DataHelpers.ToCharArray(inputHeader, 58, 32);
|
|
FileCreationDayOfYear = BitConverter.ToUInt16(inputHeader, 90);
|
|
FileCreationYear = BitConverter.ToUInt16(inputHeader, 92);
|
|
// 94 is headerSize
|
|
DataOffset = BitConverter.ToUInt32(inputHeader, 96);
|
|
NumberVLRs = BitConverter.ToUInt32(inputHeader, 100);
|
|
PointDataRecordFormat = inputHeader[104];
|
|
PointDataRecordLength = BitConverter.ToUInt16(inputHeader, 105);
|
|
LegacyNumberOfPointRecords = BitConverter.ToUInt32(inputHeader, 107);
|
|
LegacyNumberOfPointByReturn = DataHelpers.ToUintArray(inputHeader, 111, 20);
|
|
X_scaleFactor = BitConverter.ToDouble(inputHeader, 131);
|
|
Y_scaleFactor = BitConverter.ToDouble(inputHeader, 139);
|
|
Z_scaleFactor = BitConverter.ToDouble(inputHeader, 147);
|
|
X_offset = BitConverter.ToDouble(inputHeader, 155);
|
|
Y_offset = BitConverter.ToDouble(inputHeader, 163);
|
|
z_offset = BitConverter.ToDouble(inputHeader, 171);
|
|
X_max = BitConverter.ToDouble(inputHeader, 179);
|
|
X_min = BitConverter.ToDouble(inputHeader, 187);
|
|
Y_max = BitConverter.ToDouble(inputHeader, 195);
|
|
Y_min = BitConverter.ToDouble(inputHeader, 203);
|
|
Z_max = BitConverter.ToDouble(inputHeader, 211);
|
|
Z_min = BitConverter.ToDouble(inputHeader, 219);
|
|
if (versionMinor >= 4)
|
|
{
|
|
StartOfWaveformDPR = BitConverter.ToUInt64(inputHeader, 227);
|
|
StartOfFirstExtendedVLR = BitConverter.ToUInt64(inputHeader, 235);
|
|
NumberOfExtendedVLRs = BitConverter.ToUInt32(inputHeader, 243);
|
|
numberPointRecords = BitConverter.ToUInt64(inputHeader, 247);
|
|
NumberPointsByReturn = DataHelpers.ToULongArray(inputHeader, 255, 120);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("Signature: " + new string(FileSignature) + Environment.NewLine);
|
|
sb.Append("SourceID: " + FileSourceID.ToString() + Environment.NewLine);
|
|
sb.Append("Global Encoding: " + GlobalEncoding.ToString() + Environment.NewLine);
|
|
sb.Append("GUIDData1: " + GUIDData11.ToString() + Environment.NewLine);
|
|
sb.Append("GUIDData2: " + GUIDData21.ToString() + Environment.NewLine);
|
|
sb.Append("GUIDData3: " + GUIDData31.ToString() + Environment.NewLine);
|
|
sb.Append("GUIDData4: ");
|
|
foreach (byte data in GUIDData41)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
sb.Append((char)data);
|
|
}
|
|
}
|
|
sb.Append(Environment.NewLine);
|
|
sb.Append("Version: " + VersionMajor.ToString() + "." + VersionMinor.ToString() + Environment.NewLine);
|
|
sb.Append("System Identifier: "); sb.Append(SystemIdentifier); sb.Append(Environment.NewLine);
|
|
sb.Append("Generating Software: "); sb.Append(GeneratingSoftware); sb.Append(Environment.NewLine);
|
|
DateTime creationDate = new DateTime(FileCreationYear, 1, 1);
|
|
creationDate = creationDate.AddDays(FileCreationDayOfYear);
|
|
sb.Append("Creation Date: " + creationDate.ToShortDateString() + Environment.NewLine);
|
|
sb.Append("Header Length: " + HeaderSize.ToString() + Environment.NewLine);
|
|
sb.Append("Data Offset: " + DataOffset.ToString() + Environment.NewLine);
|
|
sb.Append("Number VRLs: " + NumberVLRs.ToString() + Environment.NewLine);
|
|
sb.Append("PointDataFormat: " + PointDataRecordFormat.ToString() + Environment.NewLine);
|
|
sb.Append("PointDataLength: " + PointDataRecordLength.ToString() + Environment.NewLine);
|
|
sb.Append("Legacy #PDRs: " + LegacyNumberOfPointRecords.ToString() + Environment.NewLine);
|
|
sb.Append("Legacy #PDR returns: ");
|
|
foreach (uint legacyReturn in LegacyNumberOfPointByReturn)
|
|
{
|
|
sb.Append(legacyReturn);
|
|
sb.Append(" ");
|
|
}
|
|
sb.Append(Environment.NewLine);
|
|
sb.Append("X Scale Factor: " + X_scaleFactor.ToString() + Environment.NewLine);
|
|
sb.Append("Y Scale Factor: " + Y_scaleFactor.ToString() + Environment.NewLine);
|
|
sb.Append("Z Scale Factor: " + Z_scaleFactor.ToString() + Environment.NewLine);
|
|
sb.Append("X Offset: " + X_offset.ToString() + Environment.NewLine);
|
|
sb.Append("Y Offset: " + Y_offset.ToString() + Environment.NewLine);
|
|
sb.Append("Z Offset: " + Z_offset.ToString() + Environment.NewLine);
|
|
sb.Append("X Max: " + X_max.ToString() + Environment.NewLine);
|
|
sb.Append("X Min: " + X_min.ToString() + Environment.NewLine);
|
|
sb.Append("Y Max: " + Y_max.ToString() + Environment.NewLine);
|
|
sb.Append("Y Min: " + Y_min.ToString() + Environment.NewLine);
|
|
sb.Append("Z Max: " + Z_max.ToString() + Environment.NewLine);
|
|
sb.Append("Z Min: " + Z_min.ToString() + Environment.NewLine);
|
|
if (versionMinor >= 4)
|
|
{
|
|
sb.Append("Waveform Start: " + StartOfWaveformDPR.ToString() + Environment.NewLine);
|
|
sb.Append("Extended VLR Start: " + StartOfFirstExtendedVLR.ToString() + Environment.NewLine);
|
|
sb.Append("Number eVLRs: " + NumberOfExtendedVLRs.ToString() + Environment.NewLine);
|
|
sb.Append("Number Point Records: " + NumberPointRecords.ToString() + Environment.NewLine);
|
|
sb.Append("NPR by Return: " + NumberPointsByReturn.ToString() + Environment.NewLine);
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
}
|