//-----------------------------------------------------------------------------
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");
}
protected TcLasPoint1(TsLasHeader12 prmHeader, Double prmX, Double prmY, Double prmZ,
UInt16 prmIntensity, Byte prmClassification, Byte prmUserData,
UInt16 prmPointSourceID, Byte prmBitMask, SByte prmScanAngleRank, Double prmGPSTime)
: base(prmHeader, prmX, prmY, prmZ, prmIntensity, prmClassification,
prmUserData, prmPointSourceID, prmBitMask, prmScanAngleRank)
{
GPSTime = prmGPSTime;
}
//-----------------------------------------------------------------------------
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");
}
protected TcLasPoint2(TsLasHeader12 prmHeader, Double prmX, Double prmY, Double prmZ,
UInt16 prmIntensity, Byte prmClassification, Byte prmUserData,
UInt16 prmPointSourceID, Byte prmBitMask, SByte prmScanAngleRank,
UInt16 prmRed, UInt16 prmGreen, UInt16 prmBlue)
: base(prmHeader, prmX, prmY, prmZ, prmIntensity, prmClassification,
prmUserData, prmPointSourceID, prmBitMask, prmScanAngleRank)
{
Red = prmRed;
Green = prmGreen;
Blue = prmBlue;
}
protected TcLasPoint0(TsLasHeader12 prmHeader, Double prmX, Double prmY, Double prmZ,
UInt16 prmIntensity, Byte prmClassification, Byte prmUserData,
UInt16 prmPointSourceID, Byte prmBitMask, SByte prmScanAngleRank)
{
X = prmHeader.XOffset + prmX * prmHeader.XScaleFactor;
Y = prmHeader.YOffset + prmY * prmHeader.YScaleFactor;
Z = prmHeader.ZOffset + prmZ * prmHeader.ZScaleFactor;
Intensity = prmIntensity;
Classification = prmClassification;
UserData = prmUserData;
PointSourceID = prmPointSourceID;
ReturnNumber = (byte)(prmBitMask & 7);
NumberOfReturns = (byte)((prmBitMask & 56) >> 3);
ScanDirection = (byte)((prmBitMask & 64) >> 6);
EdgeOfFlightLine = (byte)((prmBitMask & 128) >> 7);
ScanAngleRank = prmScanAngleRank;
}
public TcLasPoint0(TsLasPoint0 prmPoint, TsLasHeader12 prmHeader)
: this(prmHeader, prmPoint.X, prmPoint.Y, prmPoint.Z, prmPoint.Intensity, prmPoint.Classification,
prmPoint.UserData, prmPoint.PointSourceID, prmPoint.BitMask, prmPoint.ScanAngleRank)
{
}
//-----------------------------------------------------------------------------
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.");
}
public TcLasPoint3(TsLasPoint3 prmPoint, TsLasHeader12 prmHeader)
: this(prmHeader, prmPoint.X, prmPoint.Y, prmPoint.Z, prmPoint.Intensity, prmPoint.Classification,
prmPoint.UserData, prmPoint.PointSourceID, prmPoint.BitMask, prmPoint.ScanAngleRank,
prmPoint.Red, prmPoint.Green, prmPoint.Blue, prmPoint.GPSTime)
{
}
//-----------------------------------------------------------------------------
/// <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.");
}
