private static void NullPoint()
{
vtkPoints points = vtkPoints.New();
points.InsertNextPoint(1, 1, 1);
points.InsertNextPoint(2, 2, 2);
points.InsertNextPoint(3, 3, 3);
vtkPolyData polydata = vtkPolyData.New();
polydata.SetPoints(points);
vtkFloatArray floatArray = vtkFloatArray.New();
floatArray.SetNumberOfValues(3);
floatArray.SetNumberOfComponents(1);
floatArray.SetName("FloatArray");
for (int i = 0; i < 3; i++)
{
floatArray.SetValue(i, 2);
}
polydata.GetPointData().AddArray(floatArray);
vtkIntArray intArray = vtkIntArray.New();
intArray.SetNumberOfValues(3);
intArray.SetNumberOfComponents(1);
intArray.SetName("IntArray");
for (int i = 0; i < 3; i++)
{
intArray.SetValue(i, 2);
}
polydata.GetPointData().AddArray(intArray);
Console.WriteLine("PointIdx x y z " + "floatArray" + " " + "intArray");
Console.WriteLine("----------------------------------------");
for (int i = 0; i < 3; i++)
{
double[] p = polydata.GetPoint(i);
vtkFloatArray pointsFloatArray = vtkFloatArray.SafeDownCast(polydata.GetPointData().GetArray("FloatArray"));
vtkIntArray pointsIntArray = vtkIntArray.SafeDownCast(polydata.GetPointData().GetArray("IntArray"));
Console.WriteLine(" " + i + " " + p[0] + " " + p[1] + " " + p[2] + " "
+ pointsFloatArray.GetValue(i) + " " + pointsIntArray.GetValue(i));
}
polydata.GetPointData().NullPoint(1);
polydata.Modified();
Console.WriteLine("");
for (int i = 0; i < 3; i++)
{
double[] p = polydata.GetPoint(i);
vtkFloatArray pointsFloatArray = vtkFloatArray.SafeDownCast(polydata.GetPointData().GetArray("FloatArray"));
vtkIntArray pointsIntArray = vtkIntArray.SafeDownCast(polydata.GetPointData().GetArray("IntArray"));
Console.WriteLine(" " + i + " " + p[0] + " " + p[1] + " " + p[2] + " "
+ pointsFloatArray.GetValue(i) + " " + pointsIntArray.GetValue(i));
}
}
public static void SetHSectionPoints()
{
HZArray = vtkFloatArray.New();
HZArray.SetName("HZArray");
HZArray.SetNumberOfComponents(1);
HArray = vtkFloatArray.New();
HArray.SetName("HArray");
HArray.SetNumberOfComponents(1);
for (var i = 0; i < ImageWidth; ++i)
{
HArray.InsertNextTuple1(i);
HZArray.InsertNextTuple1(PolyData.GetPoint(HSectionNum * ImageWidth + i)[2]);
}
}
public static void SetVSectionPoints()
{
VArray = vtkFloatArray.New();
VArray.SetName("VArray");
VArray.SetNumberOfComponents(1);
VZArray = vtkFloatArray.New();
VZArray.SetName("VZArray");
VZArray.SetNumberOfComponents(1);
for (var i = 0; i < ImageHeight; i++)
{
VArray.InsertNextTuple1(i);
VZArray.InsertNextTuple1(PolyData.GetPoint(VSectionNum + i * ImageWidth)[2]);
}
}
public static void SetVSectionPoints(Rectangle rect)
{
VArray = vtkFloatArray.New();
VArray.SetName("VArray");
VArray.SetNumberOfComponents(1);
VZArray = vtkFloatArray.New();
VZArray.SetName("VZArray");
VZArray.SetNumberOfComponents(1);
VSectionNum = rect.Width / 2;
for (var i = 0; i < rect.Height; i++)
{
VArray.InsertNextTuple1(i);
VZArray.InsertNextTuple1(RectPolyData.GetPoint(VSectionNum + i * rect.Width)[2]);
}
}
public static void SetHSectionPoints(Rectangle rect)
{
HZArray = vtkFloatArray.New();
HZArray.SetName("HZArray");
HZArray.SetNumberOfComponents(1);
HArray = vtkFloatArray.New();
HArray.SetName("HArray");
HArray.SetNumberOfComponents(1);
HSectionNum = rect.Height / 2;
for (var i = 0; i < rect.Width; ++i)
{
HArray.InsertNextTuple1(i);
HZArray.InsertNextTuple1(RectPolyData.GetPoint(HSectionNum * rect.Width + i)[2]);
}
}
private void WeightedTransformFilter()
{
// Use a sphere as a basis of the shape
vtkSphereSource sphere = vtkSphereSource.New();
sphere.SetPhiResolution(40);
sphere.SetThetaResolution(40);
sphere.Update();
vtkPolyData sphereData = sphere.GetOutput();
// Create a data array to hold the weighting coefficients
vtkFloatArray tfarray = vtkFloatArray.New();
int npoints = sphereData.GetNumberOfPoints();
tfarray.SetNumberOfComponents(2);
tfarray.SetNumberOfTuples(npoints);
// Parameterize the sphere along the z axis, and fill the weights
// with (1.0-a, a) to linearly interpolate across the shape
IntPtr pPoint = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * 3);
double[] point = new double[3];
for (int i = 0; i < npoints; i++)
{
sphereData.GetPoint(i, pPoint);
Marshal.Copy(pPoint, point, 0, 3);
double x = point[0];
double y = point[1];
double z = point[2];
double zn = z + 0.5;
double zn1 = 1.0 - zn;
if (zn > 1.0)
{
zn = 1.0;
}
if (zn1 < 0.0)
{
zn1 = 0.0;
}
tfarray.SetComponent(i, 0, zn1);
tfarray.SetComponent(i, 1, zn);
}
Marshal.FreeHGlobal(pPoint);
// Create field data to hold the array, and bind it to the sphere
vtkFieldData fd = vtkFieldData.New();
tfarray.SetName("weights");
sphereData.GetPointData().AddArray(tfarray);
// Use an ordinary transform to stretch the shape
vtkTransform stretch = vtkTransform.New();
stretch.Scale(1, 1, 3.2);
vtkTransformFilter stretchFilter = vtkTransformFilter.New();
stretchFilter.SetInputConnection(sphereData.GetProducerPort());
stretchFilter.SetTransform(stretch);
// Now, for the weighted transform stuff
vtkWeightedTransformFilter weightedTrans = vtkWeightedTransformFilter.New();
// Create two transforms to interpolate between
vtkTransform identity = vtkTransform.New();
identity.Identity();
vtkTransform rotated = vtkTransform.New();
double rotatedAngle = 45;
rotated.RotateX(rotatedAngle);
weightedTrans.SetNumberOfTransforms(2);
weightedTrans.SetTransform(identity, 0);
weightedTrans.SetTransform(rotated, 1);
// which data array should the filter use ?
weightedTrans.SetWeightArray("weights");
weightedTrans.SetInputConnection(stretchFilter.GetOutputPort());
vtkPolyDataMapper weightedTransMapper = vtkPolyDataMapper.New();
weightedTransMapper.SetInputConnection(weightedTrans.GetOutputPort());
vtkActor weightedTransActor = vtkActor.New();
weightedTransActor.SetMapper(weightedTransMapper);
weightedTransActor.GetProperty().SetDiffuseColor(0.8, 0.8, 0.1);
weightedTransActor.GetProperty().SetRepresentationToSurface();
// get a reference to the renderwindow of our renderWindowControl1
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
// renderer
vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
// set background color
renderer.SetBackground(0.2, 0.3, 0.4);
// add our actor to the renderer
renderer.AddActor(weightedTransActor);
renderer.ResetCamera();
renderer.GetActiveCamera().Azimuth(90);
renderer.GetActiveCamera().Dolly(1);
}
// ============================= DATA COMPRESSION ===================================
public vtkUnstructuredGrid ExportGrid(Database DB, List <string> Result, int step)
{
vtkUnstructuredGrid Output = vtkUnstructuredGrid.New();
// Update Node Coordinates
UpdateNode(DB, step);
// Create Deep Copy of Gird
Output.SetPoints(Points);
// Recreate Mesh for Output Grid
foreach (Element E in DB.ElemLib.Values)
{
// ============= HEXA =================
if (E.Type.Contains("HEX") && E.PID == ID)
{
// Create Hexahedron
vtkHexahedron Hex = vtkHexahedron.New();
Hex.GetPointIds().SetNumberOfIds(8);
// Set Hexa nodes
for (int i = 0; i < 8; i++)
{
Hex.GetPointIds().SetId(i, Nodes[E.NList[i]]);
}
// Save Element index
Output.InsertNextCell(Hex.GetCellType(), Hex.GetPointIds());
}
// ============= PENTA =================
if (E.Type.Contains("PENTA") && E.PID == ID)
{
// Create Wedge
vtkWedge Penta = vtkWedge.New();
Penta.GetPointIds().SetNumberOfIds(6);
// Set Penta nodes
for (int i = 0; i < 6; i++)
{
Penta.GetPointIds().SetId(i, Nodes[E.NList[i]]);
}
// Save Element index
Output.InsertNextCell(Penta.GetCellType(), Penta.GetPointIds());
}
// ============= TETRA =================
if (E.Type.Contains("TET") && E.PID == ID)
{
// Create Tetra
vtkTetra Tetra = vtkTetra.New();
Tetra.GetPointIds().SetNumberOfIds(4);
// Set Tetra nodes
for (int i = 0; i < 4; i++)
{
Tetra.GetPointIds().SetId(i, Nodes[E.NList[i]]);
}
// Save Element index
Output.InsertNextCell(Tetra.GetCellType(), Tetra.GetPointIds());
}
}
foreach (string res in Result)
{
foreach (vtkFloatArray array in PointScalar)
{
if (array.GetName() == res + " INC " + step.ToString())
{
vtkFloatArray ArrayCopy = vtkFloatArray.New();
ArrayCopy.DeepCopy(array);
ArrayCopy.SetName(res);
Output.GetPointData().AddArray(ArrayCopy);
}
}
}
Output.Update();
return(Output);
}
