public void SetColors(uint bubbleValueId, FieldDerivativeType dt, FEWorld world, IColorMap colorMap)
{
FieldValue fv = world.GetFieldValue(bubbleValueId);
System.Diagnostics.Debug.Assert(fv.IsBubble == true);
uint quantityId = fv.QuantityId;
var mesh = world.Mesh;
MeshType meshType;
int[] vertexs;
mesh.GetConnectivity(MeshId, out meshType, out vertexs);
if (Type == ElementType.Tri)
{
Colors = new float[ElemCount * 3];
for (int iTri = 0; iTri < ElemCount; iTri++)
{
// Bubble
uint feId = world.GetTriangleFEIdFromMesh(quantityId, MeshId, (uint)iTri);
System.Diagnostics.Debug.Assert(feId != 0);
double value = fv.GetShowValue((int)(feId - 1), 0, dt);
var color = colorMap.GetColor(value);
for (int iColor = 0; iColor < 3; iColor++)
{
Colors[iTri * 3 + iColor] = (float)color[iColor];
}
}
}
else if (Type == ElementType.Quad)
{
// TRIと同じでよいが要素IDを取得するメソッドが現状ない
throw new NotImplementedException();
}
}
private void SetLine(FEWorld world, uint valueId)
{
System.Diagnostics.Debug.Assert(Type == ElementType.Line);
if (Type != ElementType.Line)
{
return;
}
FieldValue fv = world.GetFieldValue(valueId);
uint quantityId = fv.QuantityId;
int feOrder;
{
uint feId = world.GetLineFEIdFromMesh(quantityId, MeshId, 0); // 先頭の要素
System.Diagnostics.Debug.Assert(feId != 0);
LineFE lineFE = world.GetLineFE(quantityId, feId);
feOrder = lineFE.Order;
ElemPtCount = lineFE.NodeCount;
}
Indexs = new uint[ElemPtCount * ElemCount];
for (int iEdge = 0; iEdge < ElemCount; iEdge++)
{
uint feId = world.GetLineFEIdFromMesh(quantityId, MeshId, (uint)iEdge);
System.Diagnostics.Debug.Assert(feId != 0);
LineFE lineFE = world.GetLineFE(quantityId, feId);
for (int iPt = 0; iPt < ElemPtCount; iPt++)
{
Indexs[iEdge * ElemPtCount + iPt] = (uint)lineFE.NodeCoordIds[iPt];
}
}
}
private void SetTri(FEWorld world, uint valueId)
{
System.Diagnostics.Debug.Assert(Type == ElementType.Tri);
if (Type != ElementType.Tri)
{
return;
}
FieldValue fv = world.GetFieldValue(valueId);
uint quantityId = fv.QuantityId;
int feOrder;
{
uint feId = world.GetTriangleFEIdFromMesh(quantityId, MeshId, 0); // 先頭の要素
System.Diagnostics.Debug.Assert(feId != 0);
TriangleFE triFE = world.GetTriangleFE(quantityId, feId);
feOrder = triFE.Order;
ElemPtCount = triFE.NodeCount;
}
Indexs = new uint[ElemPtCount * ElemCount];
for (int iTri = 0; iTri < ElemCount; iTri++)
{
uint feId = world.GetTriangleFEIdFromMesh(quantityId, MeshId, (uint)iTri);
System.Diagnostics.Debug.Assert(feId != 0);
TriangleFE triFE = world.GetTriangleFE(quantityId, feId);
for (int iPt = 0; iPt < ElemPtCount; iPt++)
{
Indexs[iTri * ElemPtCount + iPt] = (uint)triFE.NodeCoordIds[iPt];
}
}
}
public void EnableUVMap(bool isUVMap, FEWorld world)
{
if ((UVArray != null) == isUVMap)
{
return;
}
if (isUVMap)
{
uint ptCnt = VertexArray.PointCount;
UVArray = new double[ptCnt * 2];
if (!world.IsFieldValueId(ValueId))
{
return;
}
FieldValue fv = world.GetFieldValue(ValueId);
uint quantityId = fv.QuantityId;
uint coCnt = world.GetCoordCount(quantityId);
for (int coId = 0; coId < coCnt; coId++)
{
double[] c = world.GetCoord(quantityId, coId);
UVArray[coId * 2 + 0] = c[0] * TexScale;
UVArray[coId * 2 + 1] = c[1] * TexScale;
}
}
else
{
UVArray = null;
}
}
private void UpdateSymmetricTensor2(uint valueId, FieldDerivativeType dt, FEWorld world)
{
ValueDof = 6;
FieldValue fv = world.GetFieldValue(valueId);
uint quantityId = fv.QuantityId;
uint dof = fv.Dof;
System.Diagnostics.Debug.Assert(fv.IsBubble == true);
var mesh = world.Mesh;
MeshType meshType;
int[] vertexs;
mesh.GetConnectivity(MeshId, out meshType, out vertexs);
if (Type == ElementType.Tri)
{
Values = new double[ElemCount * ValueDof];
for (int iTri = 0; iTri < ElemCount; iTri++)
{
// Bubble
uint feId = world.GetTriangleFEIdFromMesh(quantityId, MeshId, (uint)iTri);
System.Diagnostics.Debug.Assert(feId != 0);
double[] sigma = new double[dof];
for (int iDof = 0; iDof < dof; iDof++)
{
sigma[iDof] = fv.GetShowValue((int)(feId - 1), iDof, dt);
}
double[] vecs;
double ls;
double[] vecl;
double ll;
GetPrincipalStressVectorForSymmetricTensor2(sigma,
out vecs, out ls,
out vecl, out ll);
Values[iTri * ValueDof + 0] = vecs[0];
Values[iTri * ValueDof + 1] = vecs[1];
Values[iTri * ValueDof + 2] = ls;
Values[iTri * ValueDof + 3] = vecl[0];
Values[iTri * ValueDof + 4] = vecl[1];
Values[iTri * ValueDof + 5] = ll;
}
}
else if (Type == ElementType.Quad)
{
// TRIと同じでよいが要素IDを取得するメソッドが現状ない
throw new NotImplementedException();
}
}
public void SetTexScale(double scale, FEWorld world)
{
TexScale = scale;
if (UVArray != null)
{
if (!world.IsFieldValueId(ValueId))
{
return;
}
FieldValue fv = world.GetFieldValue(ValueId);
uint quantityId = fv.QuantityId;
uint coCnt = world.GetCoordCount(quantityId);
for (int coId = 0; coId < coCnt; coId++)
{
double[] c = world.GetCoord(quantityId, coId);
UVArray[coId * 2 + 0] = c[0] * TexScale;
UVArray[coId * 2 + 1] = c[1] * TexScale;
}
}
}
private void Set(uint valueId, FieldDerivativeType valueDt, FEWorld world)
{
System.Diagnostics.Debug.Assert(world.IsFieldValueId(valueId));
ValueId = valueId;
var mesh = world.Mesh;
uint dim = world.Dimension;
{
if (dim == 2)
{
SutableRotMode = RotMode.RotMode2D;
}
else if (dim == 3)
{
SutableRotMode = RotMode.RotMode3D;
}
}
FieldValue fv = world.GetFieldValue(valueId);
if (fv.Type == FieldValueType.Vector2 || fv.Type == FieldValueType.Vector3)
{
Type = VectorFieldDrawerType.Vector;
}
else if (fv.Type == FieldValueType.SymmetricTensor2)
{
Type = VectorFieldDrawerType.SymmetricTensor2;
}
{
DrawParts.Clear();
IList <uint> meshIds = mesh.GetIds();
foreach (uint meshId in meshIds)
{
VectorFieldDrawPart dp = new VectorFieldDrawPart(meshId, world);
DrawParts.Add(dp);
}
}
Update(world);
}
private void UpdateVector(uint valueId, FieldDerivativeType dt, FEWorld world)
{
ValueDof = 2;
FieldValue fv = world.GetFieldValue(valueId);
uint quantityId = fv.QuantityId;
uint dof = fv.Dof;
System.Diagnostics.Debug.Assert(fv.IsBubble == true);
var mesh = world.Mesh;
MeshType meshType;
int[] vertexs;
mesh.GetConnectivity(MeshId, out meshType, out vertexs);
if (Type == ElementType.Tri)
{
Values = new double[ElemCount * ValueDof];
for (int iTri = 0; iTri < ElemCount; iTri++)
{
// Bubble
uint feId = world.GetTriangleFEIdFromMesh(quantityId, MeshId, (uint)iTri);
System.Diagnostics.Debug.Assert(feId != 0);
System.Diagnostics.Debug.Assert(dof >= ValueDof);
for (int iDof = 0; iDof < ValueDof; iDof++)
{
double u = fv.GetShowValue((int)(feId - 1), iDof, dt);
Values[iTri * ValueDof + iDof] = u;
}
}
}
else if (Type == ElementType.Quad)
{
// TRIと同じでよいが要素IDを取得するメソッドが現状ない
throw new NotImplementedException();
}
}
private void Set(uint valueId, FieldDerivativeType valueDt, bool isntDisplacementValue,
FEWorld world,
uint colorValueId, FieldDerivativeType colorValueDt)
{
var mesh = world.Mesh;
if (!world.IsFieldValueId(valueId))
{
throw new ArgumentException();
//return;
}
if (world.IsFieldValueId(colorValueId))
{
IsColorLegendDraw = true;
}
else
{
IsColorLegendDraw = false;
}
ValueId = valueId;
ValueDt = valueDt;
ColorValueId = colorValueId;
ColorValueDt = colorValueDt;
IsntDisplacementValue = isntDisplacementValue;
var fv = world.GetFieldValue(valueId);
uint quantityId = fv.QuantityId;
uint dim = world.Dimension;
uint ptCnt = 0;
if (IsNsvDraw)
{
ptCnt = fv.GetPointCount();
// あとで実装する
throw new NotImplementedException();
}
else
{
ptCnt = world.GetCoordCount(quantityId);
}
uint drawDim;
if (!IsntDisplacementValue &&
dim == 2 &&
(fv.Type == FieldValueType.Scalar || fv.Type == FieldValueType.ZScalar))
{
drawDim = 3;
}
else
{
drawDim = dim;
}
VertexArray.SetSize(ptCnt, drawDim);
{
bool isNormal = (NormalArray != null);
if (NormalArray != null)
{
NormalArray = null;
}
if (isNormal)
{
NormalArray = new double[ptCnt * 3];
}
}
{
bool isUv = (UVArray != null);
if (UVArray != null)
{
UVArray = null;
}
if (isUv)
{
UVArray = new double[ptCnt * 2];
}
}
if (drawDim == 2)
{
SutableRotMode = RotMode.RotMode2D;
}
else if (dim == 3)
{
SutableRotMode = RotMode.RotMode3D;
}
else
{
SutableRotMode = RotMode.RotMode2DH;
}
{
DrawParts.Clear();
IList <uint> meshIds = mesh.GetIds();
foreach (uint meshId in meshIds)
{
if (IsNsvDraw)
{
// あとで実装する
throw new NotImplementedException();
}
else
{
}
FaceFieldDrawPart dp = new FaceFieldDrawPart(meshId, world, valueId);
DrawParts.Add(dp);
}
}
Update(world);
}
public void Update(FEWorld world)
{
FieldValue fv = world.GetFieldValue(ValueId);
uint quantityId = fv.QuantityId;
uint dim = world.Dimension;
uint ptCnt = 0;
if (IsNsvDraw)
{
ptCnt = fv.GetPointCount();
// あとで実装する
throw new NotImplementedException();
}
else
{
ptCnt = world.GetCoordCount(quantityId);
}
System.Diagnostics.Debug.Assert(VertexArray.PointCount == ptCnt);
if (!IsntDisplacementValue)
{
// 変位を伴う場合
if (dim == 2 &&
(fv.Type == FieldValueType.Scalar || fv.Type == FieldValueType.ZScalar))
{
// 垂直方向の変位として捉える
System.Diagnostics.Debug.Assert(VertexArray.Dimension == 3);
for (int coId = 0; coId < ptCnt; coId++)
{
double[] coord = world.GetCoord(quantityId, coId);
FieldDerivativeType dt = ValueDt;
double value = fv.GetShowValue(coId, 0, dt);
VertexArray.VertexCoordArray[coId * 3 + 0] = coord[0];
VertexArray.VertexCoordArray[coId * 3 + 1] = coord[1];
VertexArray.VertexCoordArray[coId * 3 + 2] = value;
}
}
else
{
System.Diagnostics.Debug.Assert(VertexArray.Dimension == dim);
for (int coId = 0; coId < ptCnt; coId++)
{
double[] coord = world.GetCoord(quantityId, coId);
FieldDerivativeType dt = ValueDt;
for (int iDim = 0; iDim < dim; iDim++)
{
double value = fv.GetShowValue(coId, iDim, dt);
VertexArray.VertexCoordArray[coId * dim + iDim] = coord[iDim] + value;
}
}
}
}
else
{
System.Diagnostics.Debug.Assert(VertexArray.Dimension == dim);
for (int coId = 0; coId < ptCnt; coId++)
{
double[] coord = world.GetCoord(quantityId, coId);
for (int iDim = 0; iDim < dim; iDim++)
{
VertexArray.VertexCoordArray[coId * dim + iDim] = coord[iDim];
}
}
}
if (world.IsFieldValueId(ColorValueId))
{
FieldValue colorfv = world.GetFieldValue(ColorValueId);
FieldDerivativeType dt = ColorValueDt;
bool isBubble = colorfv.IsBubble;
uint colorQuantityId = colorfv.QuantityId;
uint colorPtCnt = world.GetCoordCount(colorQuantityId);
if (!ColorMap.IsFixedMinMax)
{
double min;
double max;
colorfv.GetMinMaxShowValue(out min, out max, 0, dt);
ColorMap.MinValue = min;
ColorMap.MaxValue = max;
}
if (!isBubble)
{
// color is assigned to vertex
if (ColorArray == null)
{
ColorArray = new float[colorPtCnt * 4];
}
for (int coId = 0; coId < colorPtCnt; coId++)
{
double value = colorfv.GetShowValue(coId, 0, dt);
double[] color = ColorMap.GetColor(value);
ColorArray[coId * 4] = (float)color[0];
ColorArray[coId * 4 + 1] = (float)color[1];
ColorArray[coId * 4 + 2] = (float)color[2];
ColorArray[coId * 4 + 3] = 0.0f;
}
}
else
{
// color is assigned to face
for (int idp = 0; idp < DrawParts.Count; idp++)
{
FaceFieldDrawPart dp = DrawParts[idp];
dp.SetColors(ColorValueId, dt, world, ColorMap);
}
}
}
if (NormalArray != null)
{
MakeNormal();
}
if (UVArray != null)
{
for (int coId = 0; coId < ptCnt; coId++)
{
double[] coord = world.GetCoord(quantityId, coId);
UVArray[coId * 2 + 0] = coord[0] * TexScale;
UVArray[coId * 2 + 1] = coord[1] * TexScale;
}
}
}
private void Set(uint valueId, FieldDerivativeType valueDt,
bool isntDisplacementValue,
bool isDrawInnerEdge,
FEWorld world)
{
var mesh = world.Mesh;
if (!world.IsFieldValueId(valueId))
{
throw new ArgumentException();
//return;
}
ValueId = valueId;
ValueDt = valueDt;
IsntDisplacementValue = isntDisplacementValue;
var fv = world.GetFieldValue(ValueId);
// 線要素を生成
uint quantityId = fv.QuantityId;
if (isDrawInnerEdge)
{
// 内部の全ての辺を描画
LineFEs = world.MakeBoundOfElements(quantityId);
}
else
{
// 境界の辺だけ描画
LineFEs = new List <LineFE>();
IList <MeshBarArray> barArrays = mesh.GetBarArrays();
foreach (MeshBarArray barArray in barArrays)
{
uint eCadId = barArray.ECadId;
IList <int> allCoIds = world.GetCoordIdsFromCadId(quantityId, eCadId, CadElementType.Edge);
for (int i = 0; i < (allCoIds.Count - 1); i++)
{
int workFEOrder = 1;
LineFE lineFE = new LineFE(workFEOrder);
{
int[] coIds = { allCoIds[i], allCoIds[i + 1] };
lineFE.SetVertexCoordIds(coIds);
lineFE.SetNodeCoordIds(coIds);
}
LineFEs.Add(lineFE);
}
}
}
int feOrder;
{
LineFE lineFE = LineFEs[0]; // 先頭の要素
feOrder = lineFE.Order;
LinePtCount = lineFE.NodeCount;
}
uint ptCnt = LineCount * LinePtCount;
uint dim = world.Dimension;
uint drawDim;
if (!IsntDisplacementValue &&
dim == 2 &&
(fv.Type == FieldValueType.Scalar || fv.Type == FieldValueType.ZScalar))
{
drawDim = 3;
}
else
{
drawDim = dim;
}
VertexArray.SetSize(ptCnt, drawDim);
if (drawDim == 2)
{
SutableRotMode = RotMode.RotMode2D;
}
else if (dim == 3)
{
SutableRotMode = RotMode.RotMode3D;
}
else
{
SutableRotMode = RotMode.RotMode2DH;
}
Update(world);
}
public void Update(FEWorld world)
{
FieldValue fv = world.GetFieldValue(ValueId);
uint quantityId = fv.QuantityId;
uint dim = world.Dimension;
uint ptCnt = LineCount * LinePtCount;
uint lineCnt = LineCount;
uint drawDim = VertexArray.Dimension;
if (IsntDisplacementValue)
{
System.Diagnostics.Debug.Assert(drawDim == 2); // いまはそうなってる
for (int iEdge = 0; iEdge < lineCnt; iEdge++)
{
LineFE lineFE = LineFEs[iEdge];
for (int iPt = 0; iPt < LinePtCount; iPt++)
{
int coId = lineFE.NodeCoordIds[iPt];
double[] co = world.GetCoord(quantityId, coId);
VertexArray.VertexCoordArray[(iEdge * LinePtCount + iPt) * drawDim + 0] = co[0];
VertexArray.VertexCoordArray[(iEdge * LinePtCount + iPt) * drawDim + 1] = co[1];
}
}
}
else
{
// 変位を伴う場合
if (dim == 2 && drawDim == 3)
{
for (int iEdge = 0; iEdge < LineCount; iEdge++)
{
LineFE lineFE = LineFEs[iEdge];
System.Diagnostics.Debug.Assert(lineFE.NodeCoordIds.Length == LinePtCount);
for (int iPt = 0; iPt < LinePtCount; iPt++)
{
int coId = lineFE.NodeCoordIds[iPt];
double[] coord = world.GetCoord(quantityId, coId);
FieldDerivativeType dt = ValueDt;
double value = fv.GetShowValue(coId, 0, dt);
VertexArray.VertexCoordArray[(iEdge * LinePtCount + iPt) * drawDim + 0] = coord[0];
VertexArray.VertexCoordArray[(iEdge * LinePtCount + iPt) * drawDim + 1] = coord[1];
VertexArray.VertexCoordArray[(iEdge * LinePtCount + iPt) * drawDim + 2] = value;
}
}
}
else
{
for (int iEdge = 0; iEdge < lineCnt; iEdge++)
{
LineFE lineFE = LineFEs[iEdge];
System.Diagnostics.Debug.Assert(lineFE.NodeCoordIds.Length == LinePtCount);
for (int iPt = 0; iPt < LinePtCount; iPt++)
{
int coId = lineFE.NodeCoordIds[iPt];
double[] coord = world.GetCoord(quantityId, coId);
FieldDerivativeType dt = ValueDt;
for (int iDim = 0; iDim < drawDim; iDim++)
{
double value = fv.GetShowValue(coId, iDim, dt);
VertexArray.VertexCoordArray[(iEdge * LinePtCount + iPt) * drawDim + iDim] =
coord[iDim] + value;
}
}
}
}
}
}
