protected override void Algorithm(ref Cl3DModel p_Model)
{
if (NormalsAdded.Count != 0)
{
foreach (Cl3DModel.Cl3DModelPointIterator pt in NormalsAdded)
{
p_Model.RemovePointFromModel(pt);
}
NormalsAdded = new List <Cl3DModel.Cl3DModelPointIterator>();
}
Cl3DModel.Cl3DModelPointIterator iter = p_Model.GetIterator();
do
{
Vector NormalVector = null;
if (UsePCA)
{
ClTools.CalculateNormalVectorInPointUsingPCA(iter.X, iter.Y, iter.Z, iter.GetListOfNeighbors(), out NormalVector);
}
else
{
ClTools.CalculateNormalVectorInPoint(iter.X, iter.Y, iter.Z, iter.GetListOfNeighbors(), out NormalVector);
}
double norm = Math.Sqrt(Math.Pow(NormalVector[0], 2) + Math.Pow(NormalVector[1], 2) + Math.Pow(NormalVector[2], 2));
if (norm != 0)
{
NormalVector[0] /= (float)norm;
NormalVector[1] /= (float)norm;
NormalVector[2] /= (float)norm;
}
iter.NormalVector = NormalVector;
if (ShowNormals)
{
Cl3DModel.Cl3DModelPointIterator point = p_Model.AddPointToModel(iter.X - (float)NormalVector[0] * 3, iter.Y - (float)NormalVector[1] * 3, iter.Z - (float)NormalVector[2] * 3);
iter.AddNeighbor(point);
NormalsAdded.Add(point);
}
} while (iter.MoveToNext());
}
private void SampleUVParametriztion(Cl3DModel p_Model, out Cl3DModel.Cl3DModelPointIterator[,] SampledModel, int MatrixWidth, int MatrixHeight)
{
Cl3DModel.Cl3DModelPointIterator iter = p_Model.GetIterator();
float maxU = iter.U;
float minU = iter.U;
float maxV = iter.V;
float minV = iter.V;
do
{
if (maxU < iter.U)
{
maxU = iter.U;
}
if (maxV < iter.V)
{
maxV = iter.V;
}
if (minU > iter.U)
{
minU = iter.U;
}
if (minV > iter.V)
{
minV = iter.V;
}
} while (iter.MoveToNext());
List <Cl3DModel.Cl3DModelPointIterator>[,] SampledModelList = new List <Cl3DModel.Cl3DModelPointIterator> [MatrixWidth, MatrixHeight];
SampledModel = new Cl3DModel.Cl3DModelPointIterator[MatrixWidth, MatrixHeight];
iter = p_Model.GetIterator();
do
{
float U = iter.U - minU;
float V = iter.V - minV;
int RoundU = (int)((U / (maxU - minU)) * (MatrixWidth - 1));
int RoundV = (int)((V / (maxV - minV)) * (MatrixHeight - 1));
if (SampledModelList[RoundU, RoundV] == null)
{
SampledModelList[RoundU, RoundV] = new List <Cl3DModel.Cl3DModelPointIterator>();
}
SampledModelList[RoundU, RoundV].Add(iter.CopyIterator());
} while (iter.MoveToNext());
for (int i = 0; i < MatrixWidth; i++)
{
for (int j = 0; j < MatrixHeight; j++)
{
if (SampledModelList[i, j] != null)
{
float x = 0;
float y = 0;
float z = 0;
float u = 0;
float v = 0;
int ColorR = 0;
int ColorG = 0;
int ColorB = 0;
string specPoint = Cl3DModel.eSpecificPoints.UnspecifiedPoint.ToString();
bool isSpecific = false;
Dictionary <string, double> SumOfSpecificValues = new Dictionary <string, double>();
foreach (Cl3DModel.Cl3DModelPointIterator pts in SampledModelList[i, j])
{
pts.AlreadyVisited = true;
if (!isSpecific)
{
isSpecific = p_Model.IsThisPointInSpecificPoints(pts, ref specPoint);
}
List <string> specValues = pts.GetListOfSpecificValues();
foreach (string valueName in specValues)
{
double currentVal = 0;
pts.GetSpecificValue(valueName, out currentVal);
double countedVal = 0;
SumOfSpecificValues.TryGetValue(valueName, out countedVal);
SumOfSpecificValues.Remove(valueName);
SumOfSpecificValues.Add(valueName, countedVal + currentVal);
}
x += pts.X;
y += pts.Y;
z += pts.Z;
u += pts.U;
v += pts.V;
ColorR += pts.ColorR;
ColorG += pts.ColorG;
ColorB += pts.ColorB;
}
int Count = SampledModelList[i, j].Count;
List <Cl3DModel.Cl3DModelPointIterator> connections = new List <Cl3DModel.Cl3DModelPointIterator>();
foreach (Cl3DModel.Cl3DModelPointIterator point in SampledModelList[i, j])
{
foreach (Cl3DModel.Cl3DModelPointIterator InnerPoint in point.GetListOfNeighbors())
{
if (InnerPoint.AlreadyVisited == false)
{
connections.Add(InnerPoint);
}
}
}
Cl3DModel.Cl3DModelPointIterator pt = p_Model.AddPointToModel(x / Count,
y / Count,
z / Count);
pt.Color = Color.FromArgb(ColorR / Count,
ColorG / Count,
ColorB / Count);
pt.U = (int)((u / SampledModelList[i, j].Count) / maxU * MatrixWidth);
pt.V = (int)((v / SampledModelList[i, j].Count) / maxV * MatrixHeight);
foreach (KeyValuePair <string, double> SpecVal in SumOfSpecificValues)
{
pt.AddSpecificValue(SpecVal.Key, SpecVal.Value / Count);
}
SampledModel[i, j] = pt;
if (isSpecific)
{
p_Model.AddSpecificPoint(specPoint, pt);
}
foreach (Cl3DModel.Cl3DModelPointIterator point in SampledModelList[i, j])
{
p_Model.RemovePointFromModel(point);
}
foreach (Cl3DModel.Cl3DModelPointIterator point in connections)
{
pt.AddNeighbor(point);
}
}
}
}
}
protected override void Algorithm(ref Cl3DModel p_Model)
{
Cl3DModel.Cl3DModelPointIterator Center = p_Model.GetSpecificPoint(Cl3DModel.eSpecificPoints.NoseTip);
Cl3DModel.Cl3DModelPointIterator iter = p_Model.GetIterator();
List <Cl3DModel.Cl3DModelPointIterator> BoundaryVertexes = new List <Cl3DModel.Cl3DModelPointIterator>();
Cl3DModel.Cl3DModelPointIterator BeginningPoint = null;
do
{
if (iter.GetListOfNeighbors().Count <= 7)
{
iter.AlreadyVisited = true;
// iter.Color = Color.Red;
if (BeginningPoint == null)
{
BeginningPoint = iter.CopyIterator();
}
BoundaryVertexes.Add(iter.CopyIterator());
}
} while (iter.MoveToNext());
Cl3DModel.Cl3DModelPointIterator CurrentPoint = BeginningPoint.CopyIterator();
Vector NormalVector = new Vector(3);
bool IsNextInTheQue = false;
float CurrentNo = 0;
do
{
CurrentPoint.AlreadyVisited = false;
Cl3DModel.Cl3DModelPointIterator NextPoint = null;
IsNextInTheQue = false;
foreach (Cl3DModel.Cl3DModelPointIterator neighbor in CurrentPoint.GetListOfNeighbors())
{
if (neighbor.AlreadyVisited) // means next in the que
{
NextPoint = neighbor.CopyIterator();
IsNextInTheQue = true;
break;
}
}
if (NextPoint == null)
{
break;
}
Vector tmpVectorCurr = new Vector(new double[] { (CurrentPoint.X - Center.X), (CurrentPoint.Y - Center.Y), (CurrentPoint.Z - Center.Z) });
Vector tmpVectorNext = new Vector(new double[] { (NextPoint.X - Center.X), (NextPoint.Y - Center.Y), (NextPoint.Z - Center.Z) });
NormalVector[0] += (tmpVectorNext[1] * tmpVectorCurr[2] - tmpVectorNext[2] * tmpVectorCurr[1]);
NormalVector[1] += (tmpVectorNext[2] * tmpVectorCurr[0] - tmpVectorNext[0] * tmpVectorCurr[2]);
NormalVector[2] += (tmpVectorNext[0] * tmpVectorCurr[1] - tmpVectorNext[1] * tmpVectorCurr[0]);
NormalVector /= 2;
CurrentPoint.Color = ClTools.GetColorRGB(CurrentNo / BoundaryVertexes.Count, 1f);
CurrentNo++;
CurrentPoint = NextPoint.CopyIterator();
} while (IsNextInTheQue);
//NormalVector = NormalVector.Normalize();
Center.AddNeighbor(p_Model.AddPointToModel((float)NormalVector[0] + Center.X, (float)NormalVector[1] + Center.Y, (float)NormalVector[2] + Center.Z));
/* Cl3DModel.Cl3DModelPointIterator iter = p_Model.GetIterator();
* while(iter.IsValid())
* {
* float X = iter.X;
* float Y = iter.Y;
* float Z = iter.Z;
* ClTools.RotateXDirection(X, Y, Z, agnleX, out X, out Y, out Z);
* ClTools.RotateYDirection(X, Y, Z, angleY, out X, out Y, out Z);
* ClTools.RotateZDirection(X, Y, Z, agnleZ, out X, out Y, out Z);
*
* iter.X = X;
* iter.Y = Y;
* iter.Z = Z;
*
* if (!iter.MoveToNext())
* break;
* }
*/
}
protected override void Algorithm(ref Cl3DModel p_Model)
{
Cl3DModel.Cl3DModelPointIterator iter = p_Model.GetIterator();
int maxX = (int)iter.X;
int minX = (int)iter.X;
int maxY = (int)iter.Y;
int minY = (int)iter.Y;
do
{
if (maxX < iter.X)
{
maxX = (int)iter.X;
}
if (maxY < iter.Y)
{
maxY = (int)iter.Y;
}
if (minX > iter.X)
{
minX = (int)iter.X;
}
if (minY > iter.Y)
{
minY = (int)iter.Y;
}
} while (iter.MoveToNext());
int width = (maxX - minX) + 1;
int height = (maxY - minY) + 1;
List <Cl3DModel.Cl3DModelPointIterator>[,] map = new List <Cl3DModel.Cl3DModelPointIterator> [width, height];
iter = p_Model.GetIterator();
do
{
int x = (int)iter.X - minX;
int y = (int)iter.Y - minY;
if (map[x, y] == null)
{
map[x, y] = new List <Cl3DModel.Cl3DModelPointIterator>();
}
map[x, y].Add(iter.CopyIterator());
} while (iter.MoveToNext());
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (map[x, y] != null)
{
int MeanR = 0;
int MeanG = 0;
int MeanB = 0;
float MeanX = 0;
float MeanY = 0;
float MeanZ = 0;
float MeanU = 0;
float MeanV = 0;
float MeanRangeX = 0;
float MeanRangeY = 0;
Dictionary <string, List <double> > MeanSpecificValues = new Dictionary <string, List <double> >();
Cl3DModel.Cl3DModelPointIterator MaxPoint = null;
string specPoint = Cl3DModel.eSpecificPoints.UnspecifiedPoint.ToString();
bool isSpecific = false;
foreach (Cl3DModel.Cl3DModelPointIterator point in map[x, y])
{
point.AlreadyVisited = true;
if (!isSpecific)
{
isSpecific = p_Model.IsThisPointInSpecificPoints(point, ref specPoint);
}
if (m_bMean)
{
MeanR += point.ColorR;
MeanG += point.ColorG;
MeanB += point.ColorB;
MeanX += point.X;
MeanY += point.Y;
MeanZ += point.Z;
MeanU += point.U;
MeanV += point.V;
MeanRangeX += point.RangeImageX;
MeanRangeY += point.RangeImageY;
List <string> listOfValuesNames = point.GetListOfSpecificValues();
foreach (string name in listOfValuesNames)
{
List <double> listOfValues = null;
if (!MeanSpecificValues.TryGetValue(name, out listOfValues))
{
listOfValues = new List <double>();
MeanSpecificValues.Add(name, listOfValues);
}
double val = point.GetSpecificValue(name);
listOfValues.Add(val);
}
}
else
{// search for max Z
if (MaxPoint == null)
{
MaxPoint = point;
}
else if (MaxPoint.Z < point.Z)
{
MaxPoint = point;
}
}
}
if (m_bMean)
{
MeanR /= map[x, y].Count;
MeanG /= map[x, y].Count;
MeanB /= map[x, y].Count;
MeanX /= map[x, y].Count;
MeanY /= map[x, y].Count;
MeanZ /= map[x, y].Count;
MeanU /= map[x, y].Count;
MeanV /= map[x, y].Count;
MeanRangeX /= map[x, y].Count;
MeanRangeY /= map[x, y].Count;
}
else
{
MeanR = MaxPoint.ColorR;
MeanG = MaxPoint.ColorG;
MeanB = MaxPoint.ColorB;
MeanX = MaxPoint.X;
MeanY = MaxPoint.Y;
MeanZ = MaxPoint.Z;
MeanU = MaxPoint.U;
MeanV = MaxPoint.V;
MeanRangeX = MaxPoint.RangeImageX;
MeanRangeY = MaxPoint.RangeImageY;
}
List <Cl3DModel.Cl3DModelPointIterator> connections = new List <Cl3DModel.Cl3DModelPointIterator>();
foreach (Cl3DModel.Cl3DModelPointIterator point in map[x, y])
{
foreach (Cl3DModel.Cl3DModelPointIterator InnerPoint in point.GetListOfNeighbors())
{
if (InnerPoint.AlreadyVisited == false)
{
connections.Add(InnerPoint);
}
}
}
Cl3DModel.Cl3DModelPointIterator pt = p_Model.AddPointToModel((int)MeanX, (int)MeanY, MeanZ, x, width - y);
pt.Color = Color.FromArgb(MeanR, MeanG, MeanB);
pt.U = MeanU;
pt.V = MeanV;
foreach (KeyValuePair <string, List <double> > kvValues in MeanSpecificValues)
{
string valueName = kvValues.Key;
List <double> values = kvValues.Value;
double meanVal = 0;
foreach (double val in values)
{
meanVal += val;
}
meanVal /= values.Count;
pt.AddSpecificValue("Mean_" + valueName, meanVal);
}
if (isSpecific)
{
p_Model.AddSpecificPoint(specPoint, pt);
}
List <Cl3DModel.Cl3DModelPointIterator> lista = map[x, y];
for (int i = 0; i < lista.Count; i++)
{
p_Model.RemovePointFromModel(lista[i]);
}
foreach (Cl3DModel.Cl3DModelPointIterator point in connections)
{
pt.AddNeighbor(point);
}
}
}
}
}
public override void Read(Cl3DModel p_mModel3D, string p_sFilePath)
{
try
{
using (StreamReader FileStream = File.OpenText(p_sFilePath))
{
string line = "";
int NoOfVertexes = 0;
int NoOfFaces = 0;
if ((line = FileStream.ReadLine()) == null || !line.Equals("OFF"))
{
throw new Exception("Incorrect Header");
}
if ((line = FileStream.ReadLine()) == null)
{
throw new Exception("Incerrect Header");
}
string[] splitted = line.Split(' ');
NoOfVertexes = Int32.Parse(splitted[0]);
NoOfFaces = Int32.Parse(splitted[1]);
for (int i = 0; i < NoOfVertexes; i++)
{
if ((line = FileStream.ReadLine()) == null)
{
throw new Exception("Incerrect Header");
}
splitted = line.Split(' ');
float X = float.Parse(splitted[0].Replace('.', ','));
float Y = float.Parse(splitted[1].Replace('.', ','));
float Z = float.Parse(splitted[2].Replace('.', ','));
p_mModel3D.AddPointToModel(X, Y, Z);
}
for (int i = 0; i < NoOfFaces; i++)
{
if ((line = FileStream.ReadLine()) == null)
{
throw new Exception("Incorrect Header");
}
splitted = line.Split(' ');
int noOfVect = int.Parse(splitted[0]);
if (noOfVect != 3)
{
throw new Exception("Wrong number of vertexes in the face");
}
int vertex1 = int.Parse(splitted[1]);
int vertex2 = int.Parse(splitted[2]);
int vertex3 = int.Parse(splitted[3]);
Cl3DModel.Cl3DModelPointIterator iter = p_mModel3D.GetIterator();
Cl3DModel.Cl3DModelPointIterator iter2 = p_mModel3D.GetIterator();
if (!iter.MoveToPoint((uint)vertex1))
{
throw new Exception("Cannot find the point with ID: " + vertex1.ToString());
}
if (!iter2.MoveToPoint((uint)vertex2))
{
throw new Exception("Cannot find the point with ID: " + vertex2.ToString());
}
iter.AddNeighbor(iter2.CopyIterator());
if (!iter2.MoveToPoint((uint)vertex3))
{
throw new Exception("Cannot find the point with ID: " + vertex3.ToString());
}
iter.AddNeighbor(iter2.CopyIterator());
}
}
}
catch (Exception)
{
p_mModel3D.ResetModel();
throw;
}
}
public override void Read(Cl3DModel p_mModel3D, string p_sFilePath)
{
try
{
using (StreamReader FileStream = File.OpenText(p_sFilePath))
{
string line = "";
while ((line = FileStream.ReadLine()) != null)
{
if (line.Length == 0 || line.StartsWith("#"))
{
continue;
}
char[] delimiterChars = { ' ', '{', '}', '(', ')' };
string[] splited = line.Split(delimiterChars);
//splited.
if (splited[0].Equals("Vertex"))
{
int no = 1;
uint ID = UInt32.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
if (splited[no].Equals(""))
{
no++;
}
float x = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
float y = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
float z = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
Cl3DModel.Cl3DModelPointIterator iter = p_mModel3D.AddPointToModel(x, y, z, ID);
if (splited.Length > 6)
{
if (splited[no].Equals(""))
{
no++;
}
if (splited.Length > 6 && splited[no++].Equals("rgb="))
{
float r = 1;
float g = 1;
float b = 1;
r = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
g = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
b = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
iter.Color = Color.FromArgb((int)(r * 255), (int)(g * 255), (int)(b * 255));
iter.AddSpecificValue("Texture", iter.Color.ToArgb());
no++;
}
if (splited.Length > 11 && splited[no++].Equals("uv="))
{
float U = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
float V = Single.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
iter.U = U;
iter.V = V;
}
}
}
else if (splited[0].Equals("Face"))
{
int no = 2;
if (splited[no].Equals(""))
{
no++;
}
uint ID1 = UInt32.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
uint ID2 = UInt32.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
uint ID3 = UInt32.Parse(splited[no++], System.Globalization.CultureInfo.InvariantCulture);
Cl3DModel.Cl3DModelPointIterator iter1 = p_mModel3D.GetIterator();
Cl3DModel.Cl3DModelPointIterator iter2 = p_mModel3D.GetIterator();
Cl3DModel.Cl3DModelPointIterator iter3 = p_mModel3D.GetIterator();
if (!iter1.MoveToPoint(ID1))
{
throw new Exception("Cannot find point with ID: " + ID1.ToString());
}
if (!iter2.MoveToPoint(ID2))
{
throw new Exception("Cannot find point with ID: " + ID2.ToString());
}
if (!iter3.MoveToPoint(ID3))
{
throw new Exception("Cannot find point with ID: " + ID3.ToString());
}
iter1.AddNeighbor(iter2);
iter2.AddNeighbor(iter3);
iter3.AddNeighbor(iter1);
}
else
{
throw new Exception("Unknown tocken: " + splited[0]);
}
}
FileStream.Close();
}
}
catch (Exception e)
{
p_mModel3D.ResetModel();
Exception ex = new Exception("Wrong M File Format: " + p_mModel3D.ModelFilePath, e);
throw ex;
}
}
public override void Read(Cl3DModel p_mModel3D, string p_sFilePath)
{
try
{
using (StreamReader FileStream = File.OpenText(p_sFilePath))
{
string line = "";
while ((line = FileStream.ReadLine()) != null)
{
if (line.Length == 0)
{
continue;
}
if (line[0] == '#')
{
continue;
}
string[] splitted = line.Split(' ');
if (splitted[0].Equals("v"))
{
float X = float.Parse(splitted[1].Replace('.', ','));
float Y = float.Parse(splitted[2].Replace('.', ','));
float Z = float.Parse(splitted[3].Replace('.', ','));
p_mModel3D.AddPointToModel(X, Y, Z);
}
else if (splitted[0].Equals("f"))
{
if (splitted.Length != 4)
{
throw new Exception("Wrong number of vertexes in the face");
}
int vertex1 = int.Parse(splitted[1]);
int vertex2 = int.Parse(splitted[2]);
int vertex3 = int.Parse(splitted[3]);
Cl3DModel.Cl3DModelPointIterator iter = p_mModel3D.GetIterator();
Cl3DModel.Cl3DModelPointIterator iter2 = p_mModel3D.GetIterator();
if (!iter.MoveToPoint((uint)--vertex1))
{
throw new Exception("Cannot find the point with ID: " + vertex1.ToString());
}
if (!iter2.MoveToPoint((uint)--vertex2))
{
throw new Exception("Cannot find the point with ID: " + vertex2.ToString());
}
iter.AddNeighbor(iter2.CopyIterator());
if (!iter2.MoveToPoint((uint)--vertex3))
{
throw new Exception("Cannot find the point with ID: " + vertex3.ToString());
}
iter.AddNeighbor(iter2.CopyIterator());
}
}
}
}
catch (Exception)
{
p_mModel3D.ResetModel();
throw;
}
}
