internal Cl3DModelPointIterator(Cl3DModel p_mManagedModel, Cl3DModelPoint p_pActualPoint)
{
m_mManagedModel = p_mManagedModel;
m_pActualPoint = p_pActualPoint;
}
private void LoadInternalModelType(string p_sModelPath)
{
using (BinaryReader reader = new BinaryReader(File.OpenRead(p_sModelPath)))
{
string header = reader.ReadString();
string[] splitedHeader = header.Split(',');
string[] splitedFileVersion = splitedHeader[0].Split(' ');
if(splitedFileVersion[0].Equals("FileVersion:"))
m_ModelVersion = UInt32.Parse(splitedFileVersion[1]);
if (m_ModelVersion > m_iSupportedFileVersion)
throw new Exception("Unsupported file version: " + m_ModelVersion.ToString());
string oldPath = reader.ReadString();
m_sModelType = reader.ReadString();
m_NextPointId = reader.ReadUInt32();
m_uPointsCount = reader.ReadUInt32();
if (m_ModelVersion == 4 || m_ModelVersion == 5)
m_sExpression = reader.ReadString();
if (m_ModelVersion == 5)
{
int Count = reader.ReadInt32();
for( int i=0; i< Count; i++)
{
m_ListOfPreviousProcessingAlgorithms.Add(reader.ReadString());
}
}
Dictionary<String, uint> SpecificPointsDictionarry = new Dictionary<String, uint>();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
if (m_ModelVersion == 0 || m_ModelVersion == 1)
{
int sp = reader.ReadInt32();
uint PointID = reader.ReadUInt32();
SpecificPointsDictionarry.Add(((eSpecificPoints)sp).ToString(), PointID);
}
else if (m_ModelVersion == 2 || m_ModelVersion == 3 || m_ModelVersion == 4 || m_ModelVersion == 5)
{
string sp = reader.ReadString();
uint PointID = reader.ReadUInt32();
if (!SpecificPointsDictionarry.ContainsKey(sp))
SpecificPointsDictionarry.Add(sp, PointID);
else
{
ClInformationSender.SendInformation("Cannot add specific label " + sp + " to a point number " + PointID + ", this label already exists", ClInformationSender.eInformationType.eDebugText);
}
}
else
throw new Exception("Unsupported file model version: " + m_ModelVersion.ToString());
}
Cl3DModelPoint previous = null;
m_dSpecificPoints = new Dictionary<String,Cl3DModelPoint>();
m_dPointsInTheModel = new Dictionary<uint,Cl3DModelPoint>();
Dictionary<uint, KeyValuePair<Cl3DModel.Cl3DModelPointIterator, List<uint>>> Points = new Dictionary<uint, KeyValuePair<Cl3DModelPointIterator, List<uint>>>();
for (int i = 0; i < m_uPointsCount; i++)
{
List<uint> NeighborsList;
Cl3DModelPoint actual = Cl3DModelPoint.LoadPoint(reader, this, out NeighborsList);
Points.Add(actual.m_PointID, new KeyValuePair<Cl3DModelPointIterator, List<uint>>(actual.GetIterator(), NeighborsList));
m_dPointsInTheModel.Add(actual.m_PointID, actual);
if (previous == null)
{
m_pFirstPointInModel = actual;
previous = m_pFirstPointInModel;
}
else
{
previous.m_NextPoint = actual;
actual.m_PrevPoint = previous;
previous = actual;
}
}
foreach(KeyValuePair<uint, KeyValuePair<Cl3DModel.Cl3DModelPointIterator, List<uint>>> point in Points)
{
Cl3DModel.Cl3DModelPointIterator Iter = point.Value.Key;
List<uint> IterList = point.Value.Value;
foreach (uint NeighborID in IterList)
{
KeyValuePair<Cl3DModel.Cl3DModelPointIterator, List<uint>> Neighboor;
if (!Points.TryGetValue(NeighborID, out Neighboor))
throw new Exception("Cannot get point fron the dicrionary");
Iter.AddNeighbor(Neighboor.Key);
}
}
foreach(KeyValuePair<String, uint> SpecPoint in SpecificPointsDictionarry)
{
string SpecPointLabel = SpecPoint.Key;
uint SpecPointID = SpecPoint.Value;
Cl3DModelPoint pt = null;
if (m_dPointsInTheModel.TryGetValue(SpecPointID, out pt))
m_dSpecificPoints.Add(SpecPointLabel, pt);
else
throw new Exception("Cannot find point with ID: " + SpecPointID + " to assign label: " + SpecPointLabel);
}
reader.Close();
}
ClInformationSender.SendInformation("BinaryModel ver: " + m_ModelVersion.ToString(), ClInformationSender.eInformationType.eDebugText);
}
public Cl3DModelPointIterator(Cl3DModel p_mManagedModel)
{
m_mManagedModel = p_mManagedModel;
m_pActualPoint = p_mManagedModel.m_pFirstPointInModel;
}
public Cl3DModelPointIterator RemovePointFromModel(Cl3DModelPointIterator p_pPointToRemoveFromModel)
{
if (m_pFirstPointInModel == null || p_pPointToRemoveFromModel == null || p_pPointToRemoveFromModel.m_pActualPoint == null)
return null;
foreach (KeyValuePair<string, Cl3DModelPoint> point in m_dSpecificPoints)
{
if (point.Value.m_PointID == p_pPointToRemoveFromModel.PointID)
{
m_dSpecificPoints.Remove(point.Key);
break;
}
}
if (m_pFirstPointInModel.m_PointID == p_pPointToRemoveFromModel.m_pActualPoint.m_PointID)
m_pFirstPointInModel = m_pFirstPointInModel.m_NextPoint;
List<Cl3DModelPointIterator> listOfNeighbors = p_pPointToRemoveFromModel.GetListOfNeighbors();
foreach (Cl3DModelPointIterator neighbor in listOfNeighbors)
neighbor.RemoveNeighbor(p_pPointToRemoveFromModel);
if (p_pPointToRemoveFromModel.m_pActualPoint.m_NextPoint != null)
p_pPointToRemoveFromModel.m_pActualPoint.m_NextPoint.m_PrevPoint = p_pPointToRemoveFromModel.m_pActualPoint.m_PrevPoint;
if (p_pPointToRemoveFromModel.m_pActualPoint.m_PrevPoint != null)
p_pPointToRemoveFromModel.m_pActualPoint.m_PrevPoint.m_NextPoint = p_pPointToRemoveFromModel.m_pActualPoint.m_NextPoint;
m_dPointsInTheModel.Remove(p_pPointToRemoveFromModel.PointID);
Cl3DModel Model = p_pPointToRemoveFromModel.m_mManagedModel;
p_pPointToRemoveFromModel.m_mManagedModel = null;
Cl3DModelPoint ActualPoint = p_pPointToRemoveFromModel.m_pActualPoint;
p_pPointToRemoveFromModel.m_pActualPoint = null;
m_uPointsCount--;
return new Cl3DModelPointIterator(Model, ActualPoint.m_NextPoint);
}
public void ResetModel()
{
m_ModelVersion = 0;
m_sModelPath = "Unknown";
m_sModelType = "Unknown";
m_bModelHasChanged = true;
m_dSpecificPoints.Clear();
while (m_pFirstPointInModel != null)
{
m_pFirstPointInModel.m_NeighborhoodsList.Clear();
Cl3DModelPoint next = m_pFirstPointInModel.m_NextPoint;
if (next != null)
next.m_PrevPoint = null;
m_pFirstPointInModel.m_NextPoint = null;
m_pFirstPointInModel = next;
}
}
public Cl3DModelPointIterator AddPointToModel(float p_fX, float p_fY, float p_fZ, uint p_PointID)
{
if (m_dPointsInTheModel.ContainsKey(p_PointID))
throw new Exception("Such point with ID: " + p_PointID + " exists in the model");
Cl3DModelPoint newPoint = new Cl3DModelPoint(p_fX, p_fY, p_fZ, this, p_PointID);
m_dPointsInTheModel.Add(p_PointID, newPoint);
if (m_pFirstPointInModel == null)
{
m_pFirstPointInModel = newPoint;
}
else
{
newPoint.m_NextPoint = m_pFirstPointInModel;
m_pFirstPointInModel.m_PrevPoint = newPoint;
m_pFirstPointInModel = newPoint;
}
if (m_NextPointId <= p_PointID)
m_NextPointId = p_PointID + 1;
m_uPointsCount++;
return newPoint.GetIterator();
}
public static Cl3DModelPoint LoadPoint(BinaryReader reader, Cl3DModel p_pMy3DModel, out List<uint> p_NeighborsList)
{
uint PointID = reader.ReadUInt32();
float X = reader.ReadSingle();
float Y = reader.ReadSingle();
float Z = reader.ReadSingle();
int RangeX = reader.ReadInt32();
int RangeY = reader.ReadInt32();
bool AlreadyVisited = reader.ReadBoolean();
int color = reader.ReadInt32();
float U = 0;
float V = 0;
if (p_pMy3DModel.m_ModelVersion == 3 || p_pMy3DModel.m_ModelVersion == 4 || p_pMy3DModel.m_ModelVersion == 5)
{
U = reader.ReadSingle();
V = reader.ReadSingle();
}
Cl3DModelPoint newPoint = new Cl3DModelPoint(X,Y,Z,p_pMy3DModel,PointID,RangeX,RangeY);
newPoint.m_fU = U;
newPoint.m_fV = V;
newPoint.m_AlreadyVisited = AlreadyVisited;
newPoint.m_Color = Color.FromArgb(color);
p_NeighborsList = new List<uint>();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
p_NeighborsList.Add(reader.ReadUInt32());
}
count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
String SpecificPointType = "";
if (p_pMy3DModel.m_ModelVersion == 0)
{
int sp = reader.ReadInt32();
Cl3DModelPointIterator.eSpecificValues point = (Cl3DModelPointIterator.eSpecificValues)sp;
SpecificPointType = point.ToString();
}
else if (p_pMy3DModel.m_ModelVersion == 1 || p_pMy3DModel.m_ModelVersion == 2 || p_pMy3DModel.m_ModelVersion == 3 || p_pMy3DModel.m_ModelVersion == 4 || p_pMy3DModel.m_ModelVersion == 5)
{
SpecificPointType = reader.ReadString();
}
else
throw new Exception("Unsupported version of model: ver. " + p_pMy3DModel.m_ModelVersion.ToString());
double Value = reader.ReadDouble();
newPoint.m_dPointValues.Add(SpecificPointType, Value);
}
return newPoint;
}
public bool MoveToPrevious()
{
if (m_pActualPoint == null || m_pActualPoint.m_PrevPoint == null)
return false;
m_pActualPoint = m_pActualPoint.m_PrevPoint;
return true;
}
public bool MoveToPoint(uint p_uPointID)
{
if (m_pActualPoint == null)
return false;
Cl3DModelPoint tmp;
if (m_mManagedModel.m_dPointsInTheModel.TryGetValue(p_uPointID, out tmp))
{
m_pActualPoint = tmp;
return true;
}
return false;
}
public bool MoveToNext()
{
if (m_pActualPoint == null)
return false;
m_pActualPoint = m_pActualPoint.m_NextPoint;
if (m_pActualPoint == null)
return false;
else
return true;
}
