private static string ParseString(IgesFile file, string str, ref int index, string defaultValue = null)
{
if (index < str.Length && (str[index] == file.FieldDelimiter || str[index] == file.RecordDelimiter))
{
// swallow the delimiter and return the default
index++;
return(defaultValue);
}
SwallowWhitespace(str, ref index);
var sb = new StringBuilder();
// parse length
for (; index < str.Length; index++)
{
var c = str[index];
if (c == IgesFile.StringSentinelCharacter)
{
index++; // swallow H
break;
}
if (!char.IsDigit(c))
{
throw new IgesException("Expected digit");
}
sb.Append(c);
}
var lengthString = sb.ToString();
if (string.IsNullOrWhiteSpace(lengthString))
{
return(defaultValue);
}
int length = IgesParser.ParseIntStrict(lengthString);
sb.Clear();
// parse content
var value = str.Substring(index, length);
index += length;
// verify delimiter and swallow
if (index == str.Length - 1)
{
SwallowDelimiter(str, file.RecordDelimiter, ref index);
}
else
{
SwallowDelimiter(str, file.FieldDelimiter, ref index);
}
return(value);
}
public void Write(IgesFile file, Stream stream)
{
var writer = new StreamWriter(stream);
// prepare entities
var startLines = new List <string>();
var globalLines = new List <string>();
var writerState = new IgesEntity.WriterState(
new Dictionary <IgesEntity, int>(),
new List <string>(),
new List <string>(),
file.FieldDelimiter,
file.RecordDelimiter);
startLines.Add(new string(' ', IgesFile.MaxDataLength));
foreach (var entity in file.Entities)
{
if (!writerState.EntityMap.ContainsKey(entity))
{
entity.AddDirectoryAndParameterLines(writerState);
}
}
PopulateGlobalLines(file, globalLines);
// write start line
WriteLines(writer, IgesSectionType.Start, startLines);
// write global lines
WriteLines(writer, IgesSectionType.Global, globalLines);
// write directory lines
WriteLines(writer, IgesSectionType.Directory, writerState.DirectoryLines);
// write parameter lines
WriteLines(writer, IgesSectionType.Parameter, writerState.ParameterLines); // TODO: ensure space in column 65 and directory pointer in next 7
// write terminator line
writer.Write(MakeFileLine(IgesSectionType.Terminate,
string.Format("{0}{1,7}{2}{3,7}{4}{5,7}{6}{7,7}",
SectionTypeChar(IgesSectionType.Start),
startLines.Count,
SectionTypeChar(IgesSectionType.Global),
globalLines.Count,
SectionTypeChar(IgesSectionType.Directory),
writerState.DirectoryLines.Count,
SectionTypeChar(IgesSectionType.Parameter),
writerState.ParameterLines.Count),
1));
writer.Flush();
}
private static List <IgesDirectoryData> ParseDirectoryLines(IgesFile file, List <string> directoryLines)
{
var directoryEntires = new List <IgesDirectoryData>();
for (int i = 0; i < directoryLines.Count; i += 2)
{
var dir = IgesDirectoryData.FromRawLines(file, directoryLines[i], directoryLines[i + 1]);
directoryEntires.Add(dir);
}
return(directoryEntires);
}
private static int ParseInt(IgesFile file, string str, ref int index, int defaultValue = 0)
{
if (index < str.Length && (str[index] == file.FieldDelimiter || str[index] == file.RecordDelimiter))
{
// swallow the delimiter and return the default
index++;
return(defaultValue);
}
SwallowWhitespace(str, ref index);
var sb = new StringBuilder();
for (; index < str.Length; index++)
{
var c = str[index];
if (c == file.FieldDelimiter || c == file.RecordDelimiter)
{
index++; // swallow it
break;
}
if (!char.IsDigit(c))
{
throw new IgesException("Expected digit");
}
sb.Append(c);
}
var intString = sb.ToString();
if (string.IsNullOrWhiteSpace(intString))
{
return(defaultValue);
}
else
{
return(IgesParser.ParseIntStrict(sb.ToString()));
}
}
public static IgesDirectoryData FromRawLines(IgesFile file, string line1, string line2)
{
var dir = new IgesDirectoryData(file);
dir.EntityType = (IgesEntityType)GetField(line1, 1).ToInt();
dir.ParameterPointer = GetField(line1, 2).ToInt();
dir.Structure = GetField(line1, 3).ToInt();
dir.LineFontPattern = GetField(line1, 4).ToInt();
dir.Level = GetField(line1, 5).ToInt();
dir.View = GetField(line1, 6).ToInt();
dir.TransformationMatrixPointer = GetField(line1, 7).ToInt();
dir.LableDisplay = GetField(line1, 8).ToInt();
dir.StatusNumber = GetField(line1, 9);
dir.LineWeight = GetField(line2, 2).ToInt();
dir.Color = GetField(line2, 3).ToInt();
dir.LineCount = GetField(line2, 4).ToInt();
dir.FormNumber = GetField(line2, 5).ToInt();
dir.EntityLabel = GetField(line2, 8, null);
dir.EntitySubscript = GetField(line2, 9).ToUInt();
return(dir);
}
private static void ParseGlobalLines(IgesFile file, List <string> globalLines)
{
var fullString = string.Join(string.Empty, globalLines).TrimEnd();
if (string.IsNullOrEmpty(fullString))
{
return;
}
int index = 0;
ParseDelimiterCharacter(file, fullString, ref index, true); // 1
ParseDelimiterCharacter(file, fullString, ref index, false); // 2
file.Identification = ParseString(file, fullString, ref index); // 3
file.FullFileName = ParseString(file, fullString, ref index); // 4
file.SystemIdentifier = ParseString(file, fullString, ref index); // 5
file.SystemVersion = ParseString(file, fullString, ref index); // 6
file.IntegerSize = ParseInt(file, fullString, ref index); // 7
file.SingleSize = ParseInt(file, fullString, ref index); // 8
file.DecimalDigits = ParseInt(file, fullString, ref index); // 9
file.DoubleMagnitude = ParseInt(file, fullString, ref index); // 10
file.DoublePrecision = ParseInt(file, fullString, ref index); // 11
file.Identifier = ParseString(file, fullString, ref index); // 12
file.ModelSpaceScale = ParseDouble(file, fullString, ref index); // 13
file.ModelUnits = (IgesUnits)ParseInt(file, fullString, ref index, (int)file.ModelUnits); // 14
file.CustomModelUnits = ParseString(file, fullString, ref index); // 15
file.MaxLineWeightGraduations = ParseInt(file, fullString, ref index); // 16
file.MaxLineWeight = ParseDouble(file, fullString, ref index); // 17
file.TimeStamp = ParseDateTime(ParseString(file, fullString, ref index), file.TimeStamp); // 18
file.MinimumResolution = ParseDouble(file, fullString, ref index); // 19
file.MaxCoordinateValue = ParseDouble(file, fullString, ref index); // 20
file.Author = ParseString(file, fullString, ref index); // 21
file.Organization = ParseString(file, fullString, ref index); // 22
file.IgesVersion = (IgesVersion)ParseInt(file, fullString, ref index); // 23
file.DraftingStandard = (IgesDraftingStandard)ParseInt(file, fullString, ref index); // 24
file.ModifiedTime = ParseDateTime(ParseString(file, fullString, ref index), file.ModifiedTime); // 25
file.ApplicationProtocol = ParseString(file, fullString, ref index); // 26
}
private static void PopulateEntities(IgesFile file, List <IgesDirectoryData> directoryEntries, Dictionary <int, Tuple <List <string>, string> > parameterMap)
{
var binder = new IgesReaderBinder();
for (int i = 0; i < directoryEntries.Count; i++)
{
var dir = directoryEntries[i];
var parameterValues = parameterMap[dir.ParameterPointer].Item1;
var comment = parameterMap[dir.ParameterPointer].Item2;
var entity = IgesEntity.FromData(dir, parameterValues, binder);
if (entity != null)
{
entity.Comment = comment;
var directoryIndex = (i * 2) + 1;
entity.BindPointers(dir, binder);
entity.OnAfterRead(dir);
var postProcessed = entity.PostProcess();
binder.EntityMap[directoryIndex] = postProcessed;
file.Entities.Add(postProcessed);
}
}
binder.BindRemainingEntities();
}
private static void ParseDelimiterCharacter(IgesFile file, string str, ref int index, bool readFieldSeparator)
{
// verify length
if (index >= str.Length)
{
throw new IgesException("Unexpected end of input");
}
// could be empty
if (readFieldSeparator)
{
if (str[index] == IgesFile.DefaultFieldDelimiter)
{
index++;
return;
}
}
else
{
if (str[index] == file.FieldDelimiter || str[index] == IgesFile.DefaultRecordDelimiter)
{
index++;
return;
}
}
if (str[index] != '1')
{
throw new IgesException("Expected delimiter of length 1");
}
index++;
// verify 'H' separator
if (index >= str.Length)
{
throw new IgesException("Unexpected end of input");
}
if (str[index] != IgesFile.StringSentinelCharacter)
{
throw new IgesException("Unexpected string sentinel character");
}
index++;
// get the separator character and set it
if (index >= str.Length)
{
throw new IgesException("Expected delimiter character");
}
var separator = str[index];
if (readFieldSeparator)
{
file.FieldDelimiter = separator;
}
else
{
if (separator == file.FieldDelimiter)
{
throw new IgesException("Record delimiter cannot match field delimiter");
}
file.RecordDelimiter = separator;
}
index++;
// verify delimiter
if (index >= str.Length)
{
throw new IgesException("Unexpected end of input");
}
separator = str[index];
if (separator != file.FieldDelimiter && separator != file.RecordDelimiter)
{
throw new IgesException("Expected field or record delimiter");
}
index++; // swallow it
}
public static IgesFile Load(Stream stream)
{
var file = new IgesFile();
var allLines = new StreamReader(stream).ReadToEnd().Split("\n".ToCharArray()).Select(s => s.TrimEnd()).Where(line => !string.IsNullOrEmpty(line));
string terminateLine = null;
var startLines = new List <string>();
var globalLines = new List <string>();
var directoryLines = new List <string>();
var parameterLines = new List <string>();
var sectionLines = new Dictionary <IgesSectionType, List <string> >()
{
{ IgesSectionType.Start, startLines },
{ IgesSectionType.Global, globalLines },
{ IgesSectionType.Directory, directoryLines },
{ IgesSectionType.Parameter, parameterLines }
};
foreach (var line in allLines)
{
if (line.Length != 80)
{
throw new IgesException("Expected line length of 80 characters.");
}
var data = line.Substring(0, IgesFile.MaxDataLength);
var sectionType = SectionTypeFromCharacter(line[IgesFile.MaxDataLength]);
var lineNumber = IgesParser.ParseIntStrict(line.Substring(IgesFile.MaxDataLength + 1).TrimStart());
if (sectionType == IgesSectionType.Terminate)
{
if (terminateLine != null)
{
throw new IgesException("Unexpected duplicate terminate line");
}
terminateLine = data;
// verify terminate data and quit
var startCount = IgesParser.ParseIntStrict(terminateLine.Substring(1, 7));
var globalCount = IgesParser.ParseIntStrict(terminateLine.Substring(9, 7));
var directoryCount = IgesParser.ParseIntStrict(terminateLine.Substring(17, 7));
var parameterCount = IgesParser.ParseIntStrict(terminateLine.Substring(25, 7));
if (startLines.Count != startCount)
{
throw new IgesException("Incorrect number of start lines reported");
}
if (globalLines.Count != globalCount)
{
throw new IgesException("Incorrect number of global lines reported");
}
if (directoryLines.Count != directoryCount)
{
throw new IgesException("Incorrect number of directory lines reported");
}
if (parameterLines.Count != parameterCount)
{
throw new IgesException("Incorrect number of parameter lines reported");
}
break;
}
else
{
if (sectionType == IgesSectionType.Parameter)
{
data = data.Substring(0, data.Length - 8); // parameter data doesn't need its last 8 bytes
}
sectionLines[sectionType].Add(data);
if (sectionLines[sectionType].Count != lineNumber)
{
throw new IgesException("Unordered line number");
}
}
}
// don't worry if terminate line isn't present
ParseGlobalLines(file, globalLines);
var directoryEntries = ParseDirectoryLines(directoryLines);
var parameterMap = PrepareParameterLines(parameterLines, directoryEntries, file.FieldDelimiter, file.RecordDelimiter);
PopulateEntities(file, directoryEntries, parameterMap);
return(file);
}
public IgesDirectoryData(IgesFile file)
{
File = file;
}
