static public Polynome2D operator +(Polynome2D a, Polynome2D b)
{
Polynome2D result = new Polynome2D();
foreach (Term2D xyTerm in a.m_xyTerms)
{
result += xyTerm;
}
foreach (Term1D xTerm in a.m_xTerms)
{
result.AddXTerm(xTerm);
}
foreach (Term1D yTerm in a.m_yTerms)
{
result.AddYTerm(yTerm);
}
foreach (Term2D xyTerm in b.m_xyTerms)
{
result += xyTerm;
}
foreach (Term1D xTerm in b.m_xTerms)
{
result.AddXTerm(xTerm);
}
foreach (Term1D yTerm in b.m_yTerms)
{
result.AddYTerm(yTerm);
}
result.m_k = a.m_k + b.m_k;
return(result);
}
static public Polynome2D MultiplyXYPolygones(Polynome1D xPolygon, Polynome1D yPolygon)
{
Polynome2D result = new Polynome2D();
for (int x = 0; x < xPolygon.termCount; x++)
{
Term1D xTerm = xPolygon.terms[x];
for (int y = 0; y < yPolygon.termCount; y++)
{
Term1D yTerm = yPolygon.terms[y];
Term2D xyTerm = Term2D.MultiplyXYTerms(xTerm, yTerm);
result += xyTerm;
}
result.AddXTerm(xTerm * yPolygon.constant);
}
for (int y = 0; y < yPolygon.termCount; y++)
{
Term1D yTerm = yPolygon.terms[y];
result.AddYTerm(yTerm * xPolygon.constant);
}
result.m_k = xPolygon.constant * yPolygon.constant;
return(result);
}
public XmlMeshFormula(MeshVolumeFormula meshVolumeFormula)
{
m_id = meshVolumeFormula.meshID;
m_relativeVolume = meshVolumeFormula.relativeVolume;
Polynome2D formula = meshVolumeFormula.formula;
m_k = formula.k;
m_xTerms = new List <XMLTerm1D>(formula.xTerms.Count);
foreach (Term1D term in formula.xTerms)
{
m_xTerms.Add(new XMLTerm1D(term));
}
m_yTerms = new List <XMLTerm1D>(formula.yTerms.Count);
foreach (Term1D term in formula.yTerms)
{
m_yTerms.Add(new XMLTerm1D(term));
}
m_xyTerms = new List <XMLTerm2D>(formula.xyTerms.Count);
foreach (Term2D term in formula.xyTerms)
{
m_xyTerms.Add(new XMLTerm2D(term));
}
}
// Precal
#region Precalculated Volume-Rotation-Height Datas
protected void LoadMeshFormula()
{
MeshVolumeFormula xmlMeshFormula = XmlMeshFormula.FormulaForMesh(m_meshID);
if (xmlMeshFormula == null)
{
this.enabled = false;
return;
}
m_heightFormula = xmlMeshFormula.formula;
m_scaleFactor = transform.lossyScale.x * transform.lossyScale.y * transform.lossyScale.z;
m_fullVolume = xmlMeshFormula.relativeVolume * m_scaleFactor;
m_currentVolume = m_fullVolume * m_volumePercentage;
}
public MeshVolumeFormula(List <Term1D> xTerms, List <Term1D> yTerms, List <Term2D> xyTerms, float k, MeshID id, float relativeVolume)
{
m_formula = new Polynome2D(k);
foreach (Term1D term in xTerms)
{
m_formula.AddXTerm(term);
}
foreach (Term1D term in yTerms)
{
m_formula.AddYTerm(term);
}
foreach (Term2D term in xyTerms)
{
m_formula.AddXYTerm(term);
}
m_id = id;
m_relativeVolume = relativeVolume;
}
public MeshVolumeFormula(Polynome2D formula, MeshID id, float relativeVolume)
{
m_formula = new Polynome2D(formula.k);
foreach (Term1D term in formula.xTerms)
{
m_formula.AddXTerm(term);
}
foreach (Term1D term in formula.yTerms)
{
m_formula.AddYTerm(term);
}
foreach (Term2D term in formula.xyTerms)
{
m_formula.AddXYTerm(term);
}
m_id = id;
m_relativeVolume = relativeVolume;
}
static public Polynome2D operator*(Polynome2D a, float scalar)
{
Polynome2D result = new Polynome2D();
result.m_k = scalar * a.m_k;
foreach (Term1D xTerm in a.m_xTerms)
{
result.m_xTerms.Add(xTerm * scalar);
}
foreach (Term1D yTerm in a.m_yTerms)
{
result.m_yTerms.Add(yTerm * scalar);
}
foreach (Term2D xyTerm in a.m_xyTerms)
{
result.m_xyTerms.Add(xyTerm * scalar);
}
return(result);
}
private void CalculateFunction()
{
m_polynome2D = new Polynome2D();
int xCount = m_xValues.Length;
int yCount = m_yValues.Length;
// Somme de i = 0 à n de...
for (int i = 0; i < xCount; i++)
{
// Somme de j = 0 à m de...
for (int j = 0; j < yCount; j++)
{
// f(xi,yj)
float z = m_zValues[i][j];
// * Li(x) * Lj(y)
Polynome1D lix = LagrangePolynome(m_xValues, i);
Polynome1D ljy = LagrangePolynome(m_yValues, j);
m_polynome2D += z * Polynome2D.MultiplyXYPolygones(lix, ljy);
}
}
}
