//-----------------------------------------------------------------------------
private TiLasHeader GetHeaderForMergedLas(TiLasHeader prmHeader, Int64 prmAddedPoints)
{
if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader12)))
{
TsLasHeader12 header = (TsLasHeader12)prmHeader;
header.NumberOfPointRecords += (UInt32)prmAddedPoints;
header.NumberofPointsByReturn1 += (UInt32)prmAddedPoints;
return(header);
}
else if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader13)))
{
TsLasHeader13 header = (TsLasHeader13)prmHeader;
header.NumberOfPointRecords += (UInt32)prmAddedPoints;
header.NumberofPointsByReturn1 += (UInt32)prmAddedPoints;
return(header);
}
else if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader14)))
{
TsLasHeader14 header = (TsLasHeader14)prmHeader;
header.LegNumberOfPointRecords += (UInt32)prmAddedPoints;
header.LegNumberofPointsByReturn1 += (UInt32)prmAddedPoints;
header.NumberOfPointRecords += (UInt64)prmAddedPoints;
header.NumberofPointsByReturn1 += (UInt64)prmAddedPoints;
return(header);
}
throw new InvalidDataException("Header size is wrong");
}
public TcLasPoint7(TsLasPoint7 prmPoint, TsLasHeader14 prmHeader)
: this(prmHeader, prmPoint.X, prmPoint.Y, prmPoint.Z,
prmPoint.Intensity, prmPoint.BitMask, prmPoint.Classification, prmPoint.ScanAngleRank,
prmPoint.UserData, prmPoint.PointSourceID, prmPoint.GPSTime,
prmPoint.Red, prmPoint.Green, prmPoint.Blue)
{
}
public TcLasPoint9(TsLasPoint9 prmPoint, TsLasHeader14 prmHeader)
: this(prmHeader, prmPoint.X, prmPoint.Y, prmPoint.Z,
prmPoint.Intensity, prmPoint.BitMask, prmPoint.Classification, prmPoint.ScanAngleRank,
prmPoint.UserData, prmPoint.PointSourceID, prmPoint.GPSTime,
prmPoint.WPDI, prmPoint.WFOffset, prmPoint.WFPacketSize, prmPoint.WFReturnLocation,
prmPoint.WFXt, prmPoint.WFYt, prmPoint.WFZt)
{
}
public TcLasPoint8(TsLasHeader14 prmHeader, Double prmX, Double prmY, Double prmZ,
UInt16 prmIntensity, UInt16 prmBitMask, Byte prmClassification,
UInt16 prmScanAngleRank, Byte prmUserData, UInt16 prmPointSourceID, Double prmGPSTime,
UInt16 prmRed, UInt16 prmGreen, UInt16 prmBlue, UInt16 prmNIR)
: base(prmHeader, prmX, prmY, prmZ,
prmIntensity, prmBitMask, prmClassification, prmScanAngleRank,
prmUserData, prmPointSourceID, prmGPSTime, prmRed, prmGreen, prmBlue)
{
NIR = prmNIR;
}
//-----------------------------------------------------------------------------
private TiLasHeader GetHeaderForCls(TiLasHeader prmHeader, Int64 prmNewNumberOfPoints)
{
if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader12)))
{
TsLasHeader12 header = (TsLasHeader12)prmHeader;
header.NumberOfPointRecords = (UInt32)prmNewNumberOfPoints;
header.NumberofPointsByReturn1 = header.NumberOfPointRecords;
header.NumberofPointsByReturn2 = 0;
header.NumberofPointsByReturn3 = 0;
header.NumberofPointsByReturn4 = 0;
header.NumberofPointsByReturn5 = 0;
return(header);
}
else if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader13)))
{
TsLasHeader13 header = (TsLasHeader13)prmHeader;
header.NumberOfPointRecords = (UInt32)prmNewNumberOfPoints;
header.NumberofPointsByReturn1 = header.NumberOfPointRecords;
header.NumberofPointsByReturn2 = 0;
header.NumberofPointsByReturn3 = 0;
header.NumberofPointsByReturn4 = 0;
header.NumberofPointsByReturn5 = 0;
return(header);
}
else if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader14)))
{
TsLasHeader14 header = (TsLasHeader14)prmHeader;
header.LegNumberOfPointRecords = (UInt32)prmNewNumberOfPoints;
header.LegNumberofPointsByReturn1 = header.LegNumberOfPointRecords;
header.LegNumberofPointsByReturn2 = 0;
header.LegNumberofPointsByReturn3 = 0;
header.LegNumberofPointsByReturn4 = 0;
header.LegNumberofPointsByReturn5 = 0;
header.NumberOfPointRecords = (UInt64)prmNewNumberOfPoints;
header.NumberofPointsByReturn1 = header.NumberOfPointRecords;
header.NumberofPointsByReturn2 = 0;
header.NumberofPointsByReturn3 = 0;
header.NumberofPointsByReturn4 = 0;
header.NumberofPointsByReturn5 = 0;
header.NumberofPointsByReturn6 = 0;
header.NumberofPointsByReturn7 = 0;
header.NumberofPointsByReturn8 = 0;
header.NumberofPointsByReturn9 = 0;
header.NumberofPointsByReturn10 = 0;
header.NumberofPointsByReturn11 = 0;
header.NumberofPointsByReturn12 = 0;
header.NumberofPointsByReturn13 = 0;
header.NumberofPointsByReturn14 = 0;
header.NumberofPointsByReturn15 = 0;
return(header);
}
throw new InvalidDataException("Header size is wrong");
}
public TcLasPoint9(TsLasHeader14 prmHeader, Double prmX, Double prmY, Double prmZ,
UInt16 prmIntensity, UInt16 prmBitMask, Byte prmClassification,
UInt16 prmScanAngleRank, Byte prmUserData, UInt16 prmPointSourceID, Double prmGPSTime,
Byte prmWPDI, UInt64 prmWFOffset, UInt32 prmWFPacketSize, Single prmWFReturnLocation,
Single prmWFXt, Single prmWFYt, Single prmWFZt)
: base(prmHeader, prmX, prmY, prmZ,
prmIntensity, prmBitMask, prmClassification, prmScanAngleRank,
prmUserData, prmPointSourceID, prmGPSTime)
{
WPDI = prmWPDI;
WFOffset = prmWFOffset;
WFPacketSize = prmWFPacketSize;
WFReturnLocation = prmWFReturnLocation;
WFXt = prmWFXt;
WFYt = prmWFYt;
WFZt = prmWFZt;
}
public TcLasPoint6(TsLasHeader14 prmHeader, Double prmX, Double prmY, Double prmZ,
UInt16 prmIntensity, UInt16 prmBitMask, Byte prmClassification,
UInt16 prmScanAngleRank, Byte prmUserData, UInt16 prmPointSourceID, Double prmGPSTime)
{
X = prmHeader.XOffset + prmX * prmHeader.XScaleFactor;
Y = prmHeader.YOffset + prmY * prmHeader.YScaleFactor;
Z = prmHeader.ZOffset + prmZ * prmHeader.ZScaleFactor;
Intensity = prmIntensity;
Classification = prmClassification;
ScanAngleRank = prmScanAngleRank;
UserData = prmUserData;
PointSourceID = prmPointSourceID;
GPSTime = prmGPSTime;
ReturnNumber = (Byte)(prmBitMask & 15);
NumberOfReturns = (Byte)((prmBitMask & 240) >> 4);
ClassificationFlags = (Byte)(prmBitMask & 3840 >> 8);
ScannerChannel = (Byte)(prmBitMask & 12288 >> 12);
ScanDirection = (Byte)(prmBitMask & 16384 >> 14);
EdgeOfFlightLine = (Byte)(prmBitMask & 32768 >> 15);
}
//-----------------------------------------------------------------------------
protected TiLasHeader GetDuplicateEmptyHeader(TiLasHeader prmHeader)
{
prmHeader.MinX = Double.MaxValue;
prmHeader.MaxX = Double.MinValue;
prmHeader.MinY = Double.MaxValue;
prmHeader.MaxY = Double.MinValue;
prmHeader.MinZ = Double.MaxValue;
prmHeader.MaxZ = Double.MinValue;
if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader12)))
{
TsLasHeader12 header = (TsLasHeader12)(((TsLasHeader12)prmHeader).Clone());
header.NumberOfPointRecords = 0;
header.NumberofPointsByReturn1 = 0;
header.NumberofPointsByReturn2 = 0;
header.NumberofPointsByReturn3 = 0;
header.NumberofPointsByReturn4 = 0;
header.NumberofPointsByReturn5 = 0;
return(header);
}
else if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader13)))
{
TsLasHeader13 header = (TsLasHeader13)(((TsLasHeader13)prmHeader).Clone());
header.NumberOfPointRecords = 0;
header.NumberofPointsByReturn1 = 0;
header.NumberofPointsByReturn2 = 0;
header.NumberofPointsByReturn3 = 0;
header.NumberofPointsByReturn4 = 0;
header.NumberofPointsByReturn5 = 0;
return(header);
}
else if (prmHeader.HeaderSize == Marshal.SizeOf(typeof(TsLasHeader14)))
{
TsLasHeader14 header = (TsLasHeader14)(((TsLasHeader14)prmHeader).Clone());
header.LegNumberOfPointRecords = 0;
header.LegNumberofPointsByReturn1 = 0;
header.LegNumberofPointsByReturn2 = 0;
header.LegNumberofPointsByReturn3 = 0;
header.LegNumberofPointsByReturn4 = 0;
header.LegNumberofPointsByReturn5 = 0;
header.NumberOfPointRecords = 0;
header.NumberofPointsByReturn1 = 0;
header.NumberofPointsByReturn2 = 0;
header.NumberofPointsByReturn3 = 0;
header.NumberofPointsByReturn4 = 0;
header.NumberofPointsByReturn5 = 0;
header.NumberofPointsByReturn6 = 0;
header.NumberofPointsByReturn7 = 0;
header.NumberofPointsByReturn8 = 0;
header.NumberofPointsByReturn9 = 0;
header.NumberofPointsByReturn10 = 0;
header.NumberofPointsByReturn11 = 0;
header.NumberofPointsByReturn12 = 0;
header.NumberofPointsByReturn13 = 0;
header.NumberofPointsByReturn14 = 0;
header.NumberofPointsByReturn15 = 0;
return(header);
}
throw new InvalidDataException("Header size is wrong");
}
//-----------------------------------------------------------------------------
/// <summary>
/// Adjusts the LAS points for the tile and update the tile header. It takes the las file header for the block
/// of points and the modified header for this specific tile. It then update the points by taking the common LAS
/// header for the full area as reference. It also updates the tile header from the computed values of the points.
/// </summary>
/// <typeparam name="T">Type of the las point</typeparam>
/// <param name="prmHeader">LAS header to update</param>
/// <param name="prmPoints">Array of LAS points</param>
/// <param name="prmCount">Number of points to be considered</param>
/// <returns>The header as an interface to converted to the specific header structure.</returns>
protected TiLasHeader UpdateHeader <T>(TiLasHeader prmTileHeader, T[] prmPoints, Int32 prmCount) where T : TiLasPoint
{
Double X, Y, Z;
if (prmTileHeader is TsLasHeader12)
{
TsLasHeader12 tileHeader = (TsLasHeader12)prmTileHeader;
for (int i = 0; i < prmCount; i++)
{
X = tileHeader.XOffset + tileHeader.XScaleFactor * prmPoints[i].X;
Y = tileHeader.YOffset + tileHeader.YScaleFactor * prmPoints[i].Y;
Z = tileHeader.ZOffset + tileHeader.ZScaleFactor * prmPoints[i].Z;
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
switch (prmPoints[i].ReturnNumber())
{
case 1:
tileHeader.NumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
break;
}
}
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader13)
{
TsLasHeader13 tileHeader = (TsLasHeader13)prmTileHeader;
for (int i = 0; i < prmCount; i++)
{
X = tileHeader.XOffset + tileHeader.XScaleFactor * prmPoints[i].X;
Y = tileHeader.YOffset + tileHeader.YScaleFactor * prmPoints[i].Y;
Z = tileHeader.ZOffset + tileHeader.ZScaleFactor * prmPoints[i].Z;
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
switch (prmPoints[i].ReturnNumber())
{
case 1:
tileHeader.NumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
break;
}
}
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader14)
{
TsLasHeader14 tileHeader = (TsLasHeader14)prmTileHeader;
for (int i = 0; i < prmCount; i++)
{
X = tileHeader.XOffset + tileHeader.XScaleFactor * prmPoints[i].X;
Y = tileHeader.YOffset + tileHeader.YScaleFactor * prmPoints[i].Y;
Z = tileHeader.ZOffset + tileHeader.ZScaleFactor * prmPoints[i].Z;
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
tileHeader.LegNumberOfPointRecords++;
switch (prmPoints[i].ReturnNumber())
{
case 1:
tileHeader.NumberofPointsByReturn1++;
tileHeader.LegNumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
tileHeader.LegNumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
tileHeader.LegNumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
tileHeader.LegNumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
tileHeader.LegNumberofPointsByReturn5++;
break;
case 6:
tileHeader.NumberofPointsByReturn6++;
break;
case 7:
tileHeader.NumberofPointsByReturn7++;
break;
case 8:
tileHeader.NumberofPointsByReturn8++;
break;
case 9:
tileHeader.NumberofPointsByReturn9++;
break;
case 10:
tileHeader.NumberofPointsByReturn10++;
break;
case 11:
tileHeader.NumberofPointsByReturn11++;
break;
case 12:
tileHeader.NumberofPointsByReturn12++;
break;
case 13:
tileHeader.NumberofPointsByReturn13++;
break;
case 14:
tileHeader.NumberofPointsByReturn14++;
break;
case 15:
tileHeader.NumberofPointsByReturn15++;
break;
}
}
return(tileHeader);
}
throw new InvalidDataException("Couldn't update the header. Invalid data format.");
}
//-----------------------------------------------------------------------------
/// <summary>
/// Adjusts the LAS points for the tile and update the tile header. It takes the las file header for the block
/// of points and the modified header for this specific tile. It then update the points by taking the common LAS
/// header for the full area as reference. It also updates the tile header from the computed values of the points.
/// </summary>
/// <typeparam name="T">Type of the las point</typeparam>
/// <param name="prmHeader">LAS header to update</param>
/// <param name="X">X coordinate</param>
/// <param name="Y">Y coordinate</param>
/// <param name="Z">Z coordinate</param>
/// <param name="prmReturnNo">The return number from the laser shot</param>
/// <returns>The header as an interface to converted to the specific header structure.</returns>
protected TiLasHeader UpdateHeader <T>(TiLasHeader prmTileHeader, Double X, Double Y, Double Z, Byte prmReturnNo) where T : TiLasPoint
{
if (prmTileHeader is TsLasHeader12)
{
TsLasHeader12 tileHeader = (TsLasHeader12)prmTileHeader;
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
switch (prmReturnNo)
{
case 1:
tileHeader.NumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
break;
}
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader13)
{
TsLasHeader13 tileHeader = (TsLasHeader13)prmTileHeader;
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
switch (prmReturnNo)
{
case 1:
tileHeader.NumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
break;
}
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader14)
{
TsLasHeader14 tileHeader = (TsLasHeader14)prmTileHeader;
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
tileHeader.LegNumberOfPointRecords++;
switch (prmReturnNo)
{
case 1:
tileHeader.NumberofPointsByReturn1++;
tileHeader.LegNumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
tileHeader.LegNumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
tileHeader.LegNumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
tileHeader.LegNumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
tileHeader.LegNumberofPointsByReturn5++;
break;
case 6:
tileHeader.NumberofPointsByReturn6++;
break;
case 7:
tileHeader.NumberofPointsByReturn7++;
break;
case 8:
tileHeader.NumberofPointsByReturn8++;
break;
case 9:
tileHeader.NumberofPointsByReturn9++;
break;
case 10:
tileHeader.NumberofPointsByReturn10++;
break;
case 11:
tileHeader.NumberofPointsByReturn11++;
break;
case 12:
tileHeader.NumberofPointsByReturn12++;
break;
case 13:
tileHeader.NumberofPointsByReturn13++;
break;
case 14:
tileHeader.NumberofPointsByReturn14++;
break;
case 15:
tileHeader.NumberofPointsByReturn15++;
break;
}
return(tileHeader);
}
throw new InvalidDataException("Couldn't update the header. Invalid data format.");
}
//-----------------------------------------------------------------------------
/// <summary>
/// Adjusts the LAS points for the tile and update the tile header. It takes the las file header for the block
/// of points and the modified header for this specific tile. It then update the points by taking the common LAS
/// header for the full area as reference. It also updates the tile header from the computed values of the points.
/// </summary>
/// <typeparam name="T">Type of the las point</typeparam>
/// <param name="prmTileHeader">LAS header for this specific tile</param>
/// <param name="prmLasHeader">LAS header for the las file where this points belong to</param>
/// <param name="prmLasPoints">An array of las points to be updated</param>
/// <returns>The header as an interface to converted to the specific header structure.</returns>
private TiLasHeader UpdateLasInformation <T>(TiLasHeader prmTileHeader, TiLasHeader prmLasHeader, T[] prmLasPoints, Boolean prmModifyPoints) where T : TiLasPoint
{
Double X, Y, Z;
if (prmTileHeader is TsLasHeader12)
{
TsLasHeader12 tileHeader = (TsLasHeader12)prmTileHeader;
for (int i = 0; i < prmLasPoints.Length; i++)
{
X = prmLasHeader.XOffset + prmLasPoints[i].X * prmLasHeader.XScaleFactor;
Y = prmLasHeader.YOffset + prmLasPoints[i].Y * prmLasHeader.YScaleFactor;
Z = prmLasHeader.ZOffset + prmLasPoints[i].Z * prmLasHeader.ZScaleFactor;
if (prmModifyPoints)
{
prmLasPoints[i].X = (Int32)((X - m_AreaHeader.XOffset) / m_AreaHeader.XScaleFactor);
prmLasPoints[i].Y = (Int32)((Y - m_AreaHeader.YOffset) / m_AreaHeader.YScaleFactor);
prmLasPoints[i].Z = (Int32)((Z - m_AreaHeader.ZOffset) / m_AreaHeader.ZScaleFactor);
}
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
switch (prmLasPoints[i].ReturnNumber())
{
case 1:
tileHeader.NumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
break;
}
}
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader13)
{
TsLasHeader13 tileHeader = (TsLasHeader13)prmTileHeader;
for (int i = 0; i < prmLasPoints.Length; i++)
{
X = prmLasHeader.XOffset + prmLasPoints[i].X * prmLasHeader.XScaleFactor;
Y = prmLasHeader.YOffset + prmLasPoints[i].Y * prmLasHeader.YScaleFactor;
Z = prmLasHeader.ZOffset + prmLasPoints[i].Z * prmLasHeader.ZScaleFactor;
prmLasPoints[i].X = (Int32)((X - m_AreaHeader.XOffset) / m_AreaHeader.XScaleFactor);
prmLasPoints[i].Y = (Int32)((Y - m_AreaHeader.YOffset) / m_AreaHeader.YScaleFactor);
prmLasPoints[i].Z = (Int32)((Z - m_AreaHeader.ZOffset) / m_AreaHeader.ZScaleFactor);
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
switch (prmLasPoints[i].ReturnNumber())
{
case 1:
tileHeader.NumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
break;
}
}
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader14)
{
TsLasHeader14 tileHeader = (TsLasHeader14)prmTileHeader;
for (int i = 0; i < prmLasPoints.Length; i++)
{
X = prmLasHeader.XOffset + prmLasPoints[i].X * prmLasHeader.XScaleFactor;
Y = prmLasHeader.YOffset + prmLasPoints[i].Y * prmLasHeader.YScaleFactor;
Z = prmLasHeader.ZOffset + prmLasPoints[i].Z * prmLasHeader.ZScaleFactor;
prmLasPoints[i].X = (Int32)((X - m_AreaHeader.XOffset) / m_AreaHeader.XScaleFactor);
prmLasPoints[i].Y = (Int32)((Y - m_AreaHeader.YOffset) / m_AreaHeader.YScaleFactor);
prmLasPoints[i].Z = (Int32)((Z - m_AreaHeader.ZOffset) / m_AreaHeader.ZScaleFactor);
tileHeader.MinX = Math.Min(tileHeader.MinX, X);
tileHeader.MinY = Math.Min(tileHeader.MinY, Y);
tileHeader.MinZ = Math.Min(tileHeader.MinZ, Z);
tileHeader.MaxX = Math.Max(tileHeader.MaxX, X);
tileHeader.MaxY = Math.Max(tileHeader.MaxY, Y);
tileHeader.MaxZ = Math.Max(tileHeader.MaxZ, Z);
tileHeader.NumberOfPointRecords++;
tileHeader.LegNumberOfPointRecords++;
switch (prmLasPoints[i].ReturnNumber())
{
case 1:
tileHeader.NumberofPointsByReturn1++;
tileHeader.LegNumberofPointsByReturn1++;
break;
case 2:
tileHeader.NumberofPointsByReturn2++;
tileHeader.LegNumberofPointsByReturn2++;
break;
case 3:
tileHeader.NumberofPointsByReturn3++;
tileHeader.LegNumberofPointsByReturn3++;
break;
case 4:
tileHeader.NumberofPointsByReturn4++;
tileHeader.LegNumberofPointsByReturn4++;
break;
case 5:
tileHeader.NumberofPointsByReturn5++;
tileHeader.LegNumberofPointsByReturn5++;
break;
case 6:
tileHeader.NumberofPointsByReturn6++;
break;
case 7:
tileHeader.NumberofPointsByReturn7++;
break;
case 8:
tileHeader.NumberofPointsByReturn8++;
break;
case 9:
tileHeader.NumberofPointsByReturn9++;
break;
case 10:
tileHeader.NumberofPointsByReturn10++;
break;
case 11:
tileHeader.NumberofPointsByReturn11++;
break;
case 12:
tileHeader.NumberofPointsByReturn12++;
break;
case 13:
tileHeader.NumberofPointsByReturn13++;
break;
case 14:
tileHeader.NumberofPointsByReturn14++;
break;
case 15:
tileHeader.NumberofPointsByReturn15++;
break;
}
}
return(tileHeader);
}
throw new InvalidDataException("Couldn't update the header. Invalid data format.");
}
//-----------------------------------------------------------------------------
private TiLasHeader GetDefaultLasHeader()
{
TiLasHeader header;
String SystemID = "Atlass HCC";
if (m_LasPointFormat >= 0 && m_LasPointFormat <= 3)
{
header = new TsLasHeader12()
{
FileSignature = "LASF".ToCharArray(),
SourceID = 0,
GlobalEncoding = 0,
GUID1 = 0,
GUID2 = 0,
GUID3 = 0,
GUID4 = String.Empty.PadRight(8).ToCharArray(),
VersionMajor = 1,
VersionMinor = 2,
SystemID = SystemID.PadRight(32).ToCharArray(),
GeneratingSoftware = SoftwareName.PadRight(32).ToCharArray(),
NumberOfVariableLengthRecords = 1,
NumberOfPointRecords = 0,
NumberofPointsByReturn1 = 0,
NumberofPointsByReturn2 = 0,
NumberofPointsByReturn3 = 0,
NumberofPointsByReturn4 = 0,
NumberofPointsByReturn5 = 0
};
}
else if (m_LasPointFormat >= 4 && m_LasPointFormat <= 5)
{
header = new TsLasHeader13()
{
FileSignature = "LASF".ToCharArray(),
SourceID = 0,
GlobalEncoding = 0,
GUID1 = 0,
GUID2 = 0,
GUID3 = 0,
GUID4 = String.Empty.PadRight(8).ToCharArray(),
VersionMajor = 1,
VersionMinor = 3,
SystemID = SystemID.PadRight(32).ToCharArray(),
GeneratingSoftware = SoftwareName.PadRight(32).ToCharArray(),
NumberOfVariableLengthRecords = 1,
NumberOfPointRecords = 0,
NumberofPointsByReturn1 = 0,
NumberofPointsByReturn2 = 0,
NumberofPointsByReturn3 = 0,
NumberofPointsByReturn4 = 0,
NumberofPointsByReturn5 = 0,
StartOfWaveFormData = 0
};
}
else
{
header = new TsLasHeader14()
{
FileSignature = "LASF".ToCharArray(),
SourceID = 0,
GlobalEncoding = 0,
GUID1 = 0,
GUID2 = 0,
GUID3 = 0,
GUID4 = String.Empty.PadRight(8).ToCharArray(),
VersionMajor = 1,
VersionMinor = 4,
SystemID = SystemID.PadRight(32).ToCharArray(),
GeneratingSoftware = SoftwareName.PadRight(32).ToCharArray(),
NumberOfVariableLengthRecords = 1,
LegNumberOfPointRecords = 0,
LegNumberofPointsByReturn1 = 0,
LegNumberofPointsByReturn2 = 0,
LegNumberofPointsByReturn3 = 0,
LegNumberofPointsByReturn4 = 0,
LegNumberofPointsByReturn5 = 0,
NumberOfPointRecords = 0,
NumberofPointsByReturn1 = 0,
NumberofPointsByReturn2 = 0,
NumberofPointsByReturn3 = 0,
NumberofPointsByReturn4 = 0,
NumberofPointsByReturn5 = 0,
NumberofPointsByReturn6 = 0,
NumberofPointsByReturn7 = 0,
NumberofPointsByReturn8 = 0,
NumberofPointsByReturn9 = 0,
NumberofPointsByReturn10 = 0,
NumberofPointsByReturn11 = 0,
NumberofPointsByReturn12 = 0,
NumberofPointsByReturn13 = 0,
NumberofPointsByReturn14 = 0,
NumberofPointsByReturn15 = 0,
StartOfWaveFormData = 0
};
}
header.HeaderSize = (UInt16)Marshal.SizeOf(header);
header.PointOffset = (UInt32)header.HeaderSize;
header.PointDataFormatID = (Byte)m_LasPointFormat;
header.PointDataRecordLength = header.GetPointSize();
header.DoY = (UInt16)DateTime.Today.DayOfYear;
header.Year = (UInt16)DateTime.Now.Year;
header.MinX = Double.MaxValue;
header.MinY = Double.MaxValue;
header.MinZ = Double.MaxValue;
header.MaxX = Double.MinValue;
header.MaxY = Double.MinValue;
header.MaxZ = Double.MinValue;
header.XOffset = Double.MaxValue;
header.YOffset = Double.MaxValue;
header.ZOffset = Double.MaxValue;
header.XScaleFactor = Double.MaxValue;
header.YScaleFactor = Double.MaxValue;
header.ZScaleFactor = Double.MaxValue;
return(header);
}
//------------------------------------------------------------------
/// <summary>
/// This function reads a given number of points from the current location of the reader.
/// If enough points not found in the file, it returns the available points.
/// </summary>
/// <typeparam name="T">Type of the las point</typeparam>
/// <param name="prmNoOfPoints">Number of points to read</param>
/// <param name="prmHeader">LAS header interface</param>
/// <returns>An array of LAS points</returns>
public TcLasPointBase[] ReadPointsAsObject <T>(Int64 prmNoOfPoints, TiLasHeader prmHeader) where T : TiLasPoint
{
Int64 pointCounter = 0;
switch (prmHeader.PointDataFormatID)
{
case 0:
TsLasHeader12 header0 = (TsLasHeader12)prmHeader;
return(ReadPoints <TsLasPoint0>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint0(iter, header0);
return res;
}));
case 1:
TsLasHeader12 header1 = (TsLasHeader12)prmHeader;
return(ReadPoints <TsLasPoint1>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint1(iter, header1);
return res;
}));
case 2:
TsLasHeader12 header2 = (TsLasHeader12)prmHeader;
return(ReadPoints <TsLasPoint2>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint2(iter, header2);
return res;
}));
case 3:
TsLasHeader12 header3 = (TsLasHeader12)prmHeader;
return(ReadPoints <TsLasPoint3>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint3(iter, header3);
return res;
}));
case 4:
TsLasHeader13 header4 = (TsLasHeader13)prmHeader;
return(ReadPoints <TsLasPoint4>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint4(iter, header4);
return res;
}));
case 5:
TsLasHeader13 header5 = (TsLasHeader13)prmHeader;
return(ReadPoints <TsLasPoint5>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint5(iter, header5);
return res;
}));
case 6:
TsLasHeader14 header6 = (TsLasHeader14)prmHeader;
return(ReadPoints <TsLasPoint6>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint6(iter, header6);
return res;
}));
case 7:
TsLasHeader14 header7 = (TsLasHeader14)prmHeader;
return(ReadPoints <TsLasPoint7>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint7(iter, header7);
return res;
}));
case 8:
TsLasHeader14 header8 = (TsLasHeader14)prmHeader;
return(ReadPoints <TsLasPoint8>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint8(iter, header8);
return res;
}));
case 9:
TsLasHeader14 header9 = (TsLasHeader14)prmHeader;
return(ReadPoints <TsLasPoint9>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint9(iter, header9);
return res;
}));
case 10:
TsLasHeader14 header10 = (TsLasHeader14)prmHeader;
return(ReadPoints <TsLasPoint10>(prmNoOfPoints).Aggregate(new TcLasPointBase[prmNoOfPoints], (res, iter) =>
{
res[pointCounter++] = new TcLasPoint10(iter, header10);
return res;
}));
}
return(null);
}
private TiLasHeader UpdateTileCounts <T>(TiLasHeader prmTileHeader, Int32 prmSize) where T : TiLasPoint
{
if (prmTileHeader is TsLasHeader12)
{
TsLasHeader12 tileHeader = (TsLasHeader12)prmTileHeader;
tileHeader.MinX = (tileHeader.MinX + XAdjustment) - ((tileHeader.MinX + XAdjustment) % (prmSize * Factor));
tileHeader.MinY = (tileHeader.MinY + YAdjustment) - ((tileHeader.MinY + YAdjustment) % (prmSize * Factor));
tileHeader.MaxX = (tileHeader.MaxX + XAdjustment) - ((tileHeader.MaxX + XAdjustment) % (prmSize * Factor)) + (prmSize * Factor);
tileHeader.MaxY = (tileHeader.MaxY + YAdjustment) - ((tileHeader.MaxY + YAdjustment) % (prmSize * Factor)) + (prmSize * Factor);
tileHeader.NumberOfPointRecords = 0;
tileHeader.NumberofPointsByReturn1 = 0;
tileHeader.NumberofPointsByReturn2 = 0;
tileHeader.NumberofPointsByReturn3 = 0;
tileHeader.NumberofPointsByReturn4 = 0;
tileHeader.NumberofPointsByReturn5 = 0;
m_RevisedEast = (Int32)tileHeader.MinX;
m_RevisedNorth = (Int32)tileHeader.MaxY;
m_TileColumns = (Int32)(tileHeader.MaxX - tileHeader.MinX) / (prmSize * Factor);
m_TileRows = (Int32)(tileHeader.MaxY - tileHeader.MinY) / (prmSize * Factor);
m_TileBlockInfoCollection = new TcTileBlockInfoCollection(prmSize, m_TileRows, m_TileColumns);
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader13)
{
TsLasHeader13 tileHeader = (TsLasHeader13)prmTileHeader;
tileHeader.MinX = (tileHeader.MinX + XAdjustment) - ((tileHeader.MinX + XAdjustment) % (prmSize * Factor));
tileHeader.MinY = (tileHeader.MinY + YAdjustment) - ((tileHeader.MinY + YAdjustment) % (prmSize * Factor));
tileHeader.MaxX = (tileHeader.MaxX + XAdjustment) - ((tileHeader.MaxX + XAdjustment) % (prmSize * Factor)) + (prmSize * Factor);
tileHeader.MaxY = (tileHeader.MaxY + YAdjustment) - ((tileHeader.MaxY + YAdjustment) % (prmSize * Factor)) + (prmSize * Factor);
tileHeader.NumberOfPointRecords = 0;
tileHeader.NumberofPointsByReturn1 = 0;
tileHeader.NumberofPointsByReturn2 = 0;
tileHeader.NumberofPointsByReturn3 = 0;
tileHeader.NumberofPointsByReturn4 = 0;
tileHeader.NumberofPointsByReturn5 = 0;
m_RevisedEast = (Int32)tileHeader.MinX;
m_RevisedNorth = (Int32)tileHeader.MaxY;
m_TileColumns = (Int32)(tileHeader.MaxX - tileHeader.MinX) / (prmSize * Factor);
m_TileRows = (Int32)(tileHeader.MaxY - tileHeader.MinY) / (prmSize * Factor);
m_TileBlockInfoCollection = new TcTileBlockInfoCollection(prmSize, m_TileRows, m_TileColumns);
return(tileHeader);
}
else if (prmTileHeader is TsLasHeader14)
{
TsLasHeader14 tileHeader = (TsLasHeader14)prmTileHeader;
tileHeader.MinX = (tileHeader.MinX + XAdjustment) - ((tileHeader.MinX + XAdjustment) % (prmSize * Factor));
tileHeader.MinY = (tileHeader.MinY + YAdjustment) - ((tileHeader.MinY + YAdjustment) % (prmSize * Factor));
tileHeader.MaxX = (tileHeader.MaxX + XAdjustment) - ((tileHeader.MaxX + XAdjustment) % (prmSize * Factor)) + (prmSize * Factor);
tileHeader.MaxY = (tileHeader.MaxY + YAdjustment) - ((tileHeader.MaxY + YAdjustment) % (prmSize * Factor)) + (prmSize * Factor);
tileHeader.NumberOfPointRecords = 0;
tileHeader.NumberofPointsByReturn1 = 0;
tileHeader.NumberofPointsByReturn2 = 0;
tileHeader.NumberofPointsByReturn3 = 0;
tileHeader.NumberofPointsByReturn4 = 0;
tileHeader.NumberofPointsByReturn5 = 0;
tileHeader.NumberofPointsByReturn6 = 0;
tileHeader.NumberofPointsByReturn7 = 0;
tileHeader.NumberofPointsByReturn8 = 0;
tileHeader.NumberofPointsByReturn9 = 0;
tileHeader.NumberofPointsByReturn10 = 0;
tileHeader.NumberofPointsByReturn11 = 0;
tileHeader.NumberofPointsByReturn12 = 0;
tileHeader.NumberofPointsByReturn13 = 0;
tileHeader.NumberofPointsByReturn14 = 0;
tileHeader.NumberofPointsByReturn15 = 0;
tileHeader.LegNumberofPointsByReturn1 = 0;
tileHeader.LegNumberofPointsByReturn2 = 0;
tileHeader.LegNumberofPointsByReturn3 = 0;
tileHeader.LegNumberofPointsByReturn4 = 0;
tileHeader.LegNumberofPointsByReturn5 = 0;
m_RevisedEast = (Int32)tileHeader.MinX;
m_RevisedNorth = (Int32)tileHeader.MaxY;
m_TileColumns = (Int32)(tileHeader.MaxX - tileHeader.MinX) / (prmSize * Factor);
m_TileRows = (Int32)(tileHeader.MaxY - tileHeader.MinY) / (prmSize * Factor);
m_TileBlockInfoCollection = new TcTileBlockInfoCollection(prmSize, m_TileRows, m_TileColumns);
return(tileHeader);
}
throw new InvalidDataException("Couldn't update the Tile Header. Invalid data format.");
}
