static void Main(string[] args)
{
float[] frame1origin = new float[] { 0, 0, 0 };
float[] frame1XDirection = new float[] { 1, 0, 0 };
float[] frame1YDirection = new float[] { 0, 1, 0 };
Console.WriteLine(frame1YDirection[0] + " " + frame1YDirection[1] + " " + frame1YDirection[2]);
float[] frame1ZDirection = new float[] { 0, 0, 1 };
Frame frame1 = new Frame(frame1origin, frame1XDirection, frame1YDirection, frame1ZDirection);
Console.WriteLine("\nWriting frame1.vtp...");
// adjust path
frame1.Write(@"c:\vtk\vtkdata-5.8.0\Data\frame1.vtp");
float[] frame2origin = new float[] { 0, 0, 0 };
float[] frame2XDirection = new float[] { .707f, .707f, 0 };
float[] frame2YDirection = new float[] { -.707f, .707f, 0 };
float[] frame2ZDirection = new float[] { 0, 0, 1 };
Frame frame2 = new Frame(frame2origin, frame2XDirection, frame2YDirection, frame2ZDirection);
Console.WriteLine("\nWriting frame2.vtp...");
// adjust path
frame2.Write(@"c:\vtk\vtkdata-5.8.0\Data\frame2.vtp");
vtkTransform transform = vtkTransform.New();
AlignFrames(frame2, frame1, ref transform); // Brings frame2 to frame1
Console.WriteLine("\nWriting transformed.vtp...");
// adjust path
frame2.ApplyTransform(ref transform, @"c:\vtk\vtkdata-5.8.0\Data\transformed.vtp");
Console.WriteLine("\nPress any key to continue...");
Console.ReadKey();
}
public Cone(ARenderable parent)
: base(parent)
{
Name = "Cone";
cone = vtkConeSource.New();
cone.SetAngle(10);
cone.SetRadius(0.2);
cone.SetHeight(0.5);
cone.SetResolution(20);
move = vtkTransform.New();
move.Translate(_random.NextDouble(), _random.NextDouble(), _random.NextDouble());
moveFilter = vtkTransformPolyDataFilter.New();
moveFilter.SetTransform(move);
moveFilter.SetInputConnection(cone.GetOutputPort());
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(moveFilter.GetOutputPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
Actors = new ObservableCollection <vtkActor>();
Actors.Add(actor);
}
internal void ApplyTransform(ref vtkTransform transform, string filename)
{
vtkPolyData polydata = vtkPolyData.New();
CreatePolydata(ref polydata);
vtkTransformFilter transformFilter = vtkTransformFilter.New();
#if VTK_MAJOR_VERSION_5
transformFilter.SetInputConnection(polydata.GetProducerPort());
#else
transformFilter.SetInputData(polydata);
#endif
transformFilter.SetTransform(transform);
transformFilter.Update();
vtkXMLPolyDataWriter writer = vtkXMLPolyDataWriter.New();
writer.SetFileName(filename);
#if VTK_MAJOR_VERSION_5
writer.SetInputConnection(transformFilter.GetOutputPort());
#else
writer.SetInputData(transformFilter);
#endif
writer.Write();
}
public Sphere(ARenderable parent)
: base(parent)
{
Name = "Sphere";
sphere = vtkSphereSource.New();
sphere.SetThetaResolution(8);
sphere.SetPhiResolution(16);
shrink = vtkShrinkPolyData.New();
shrink.SetInputConnection(sphere.GetOutputPort());
shrink.SetShrinkFactor(0.9);
move = vtkTransform.New();
move.Translate(_random.NextDouble(), _random.NextDouble(), _random.NextDouble());
moveFilter = vtkTransformPolyDataFilter.New();
moveFilter.SetTransform(move);
moveFilter.SetInputConnection(shrink.GetOutputPort());
mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(moveFilter.GetOutputPort());
Actors = new ObservableCollection <vtkActor>();
// The actor links the data pipeline to the rendering subsystem
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.GetProperty().SetColor(1, 0, 0);
Actors.Add(actor);
}
/// <summary>
/// Update the 2D visualization when the plane moved.
/// </summary>
/// <param name="plane">PlaneWidget which changed the coordinates.</param>
public void PlaneMoved(vtkImagePlaneWidget plane)
{
vtkImageReslice reslice = vtkImageReslice.New();
vtkTransform transform = vtkTransform.New();
transform.PostMultiply();
//TODO wyznaczenie centrum okna
double[] center = { 75, 100, 0 };
transform.Translate(-center[0], -center[1], -center[2]);
transform.RotateZ(_orientation);
transform.Translate(+center[0], +center[1], +center[2]);
transform.Update();
reslice.SetInput(plane.GetResliceOutput());
reslice.SetResliceTransform(transform);
reslice.Update();
//
vtkImageData viewerInputData;
viewerInputData = reslice.GetOutput();
_lastData = viewerInputData;
_viewer.SetInput(viewerInputData);
//
//_viewer.SetInput(reslice.GetOutput());
UpdateViewer();
}
/// <summary>
/// Rotates volume along given axis.
/// </summary>
/// <param name="volume"></param>
/// <param name="angles"></param>
public static void RotateData(ref vtkImageData volume, double[] angles)
{
// Rotation along image center
double[] center = volume.GetExtent().Divide(2);
// Dimensions of rotated image
int[] outExtent = volume.GetExtent().Multiply(1.1).Round().ToInt32();
// Rotation parameters
var rotate = new vtkTransform();
rotate.Translate(center[1], center[3], center[5]);
rotate.RotateX(angles[0]);
rotate.RotateY(angles[1]);
rotate.RotateZ(angles[2]); // z angle should be 0
rotate.Translate(-center[1], -center[3], -center[5]);
// Perform rotation
var slice = new vtkImageReslice();
slice.SetInput(volume);
slice.SetResliceTransform(rotate);
slice.SetInterpolationModeToCubic();
slice.SetOutputSpacing(volume.GetSpacing()[0], volume.GetSpacing()[1], volume.GetSpacing()[2]);
slice.SetOutputOrigin(volume.GetOrigin()[0], volume.GetOrigin()[1], volume.GetOrigin()[2]);
slice.SetOutputExtent(outExtent[0], outExtent[1], outExtent[2], outExtent[3], outExtent[4], outExtent[5]);
}
private void RotateImage(RotationOperation operation)
{
vtkImageReslice reslice = vtkImageReslice.New();
vtkTransform transform = vtkTransform.New();
transform.PostMultiply();
double[] center = { 75, 100, 0 };
transform.Translate(-center[0], -center[1], -center[2]);
if (operation == RotationOperation.Forward)
{
transform.RotateZ(90);
}
else if (operation == RotationOperation.Back)
{
transform.RotateZ(-90);
}
transform.Translate(+center[0], +center[1], +center[2]);
transform.Update();
reslice.SetInput(_viewer.GetInput());
reslice.SetResliceTransform(transform);
reslice.Update();
_viewer.SetInput(reslice.GetOutput());
UpdateViewer();
}
public void UpdatePosition_OLD(double[] endPoint, double[] startPoint)
{
double[] normalizedX = new double[3];
double[] normalizedY = new double[3];
double[] normalizedZ = new double[3];
// The X axis is a vector from start to end
Subtract(endPoint, startPoint, normalizedX);
double length = vtkMath.Norm(VTKUtil.ConvertIntPtr(normalizedX));
vtkMath.Normalize(VTKUtil.ConvertIntPtr(normalizedX));
// The Z axis is an arbitrary vecotr cross X
double[] arbitrary = new double[3];
arbitrary[0] = vtkMath.Random(-10, 10);
arbitrary[1] = vtkMath.Random(-10, 10);
arbitrary[2] = vtkMath.Random(-10, 10);
// TODO FIX ME
vtkMath.Cross(VTKUtil.ConvertIntPtr(normalizedX), VTKUtil.ConvertIntPtr(arbitrary), VTKUtil.ConvertIntPtr(normalizedZ));
vtkMath.Normalize(VTKUtil.ConvertIntPtr(normalizedZ));
// The Y axis is Z cross X
// TODO FIX ME
vtkMath.Cross(VTKUtil.ConvertIntPtr(normalizedZ), VTKUtil.ConvertIntPtr(normalizedX), VTKUtil.ConvertIntPtr(normalizedY));
vtkMatrix4x4 matrix = vtkMatrix4x4.New();
// Create the direction cosine matrix
matrix.Identity();
for (int i = 0; i < 3; i++)
{
matrix.SetElement(i, 0, normalizedX[i]);
matrix.SetElement(i, 1, normalizedY[i]);
matrix.SetElement(i, 2, normalizedZ[i]);
}
// Apply the transforms
vtkTransform transform = vtkTransform.New();
transform.Translate(VTKUtil.ConvertIntPtr(startPoint));
transform.Concatenate(matrix);
//length = 500;
transform.Scale(length, length, length);
// Transform the polydata
//vtkTransformPolyDataFilter transformPD = new vtkTransformPolyDataFilter();
//transformPD.SetTransform(transform);
//transformPD.SetInputConnection(_arrowSource.GetOutputPort());
_arrowSource.Update();
_mapper.SetInput(_arrowSource.GetOutput());
_arrowActor.SetUserMatrix(transform.GetMatrix());
_arrowActor.SetMapper(_mapper);
}
public static double[] Mutiple(vtkTransform transform, double[] value)
{
vtkMatrix4x4 matrix = transform.GetMatrix();
int size = Marshal.SizeOf(typeof(double)) * value.Length;
IntPtr pre = Marshal.AllocHGlobal(size);
Marshal.Copy(value, 0, pre, value.Length);
double[] result = matrix.MultiplyDoublePoint(pre);
return(result);
}
void SimConfig_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
vtkTransform vtk_transform = vtkTransform.New();
int reg_idx = RegionsListBox.SelectedIndex;
this.TransferMatrixToVTKTransform(this.configurator.SimConfig.scenario.regions[reg_idx].region_box_spec.transform_matrix, vtk_transform);
boxRep.SetTransform(vtk_transform);
sphereActorList[reg_idx].SetUserTransform(vtk_transform);
// sphereActor.SetVisibility(1);
rwc.Invalidate();
}
public void ApplyTransform(vtkMatrix4x4 matrix)
{
vtkMatrix4x4 t = new vtkMatrix4x4();
vtkMatrix4x4.Multiply4x4(centerLineActor.GetMatrix(), matrix, t);
vtkTransform transform = new vtkTransform();
transform.SetMatrix(t);
this.centerLineActor.SetUserTransform(transform);
}
public void ApplyTransformBefore(vtkMatrix4x4 matrix)
{
vtkMatrix4x4 t = vtkMatrix4x4.New();
vtkMatrix4x4.Multiply4x4(matrix, actor.GetMatrix(), t);
vtkTransform transform = vtkTransform.New();
transform.SetMatrix(t);
this.actor.SetUserTransform(transform);
}
public void SetTransform(vtkMatrix4x4 matrix)
{
if (actor == null)
{
return;
}
vtkTransform transform = vtkTransform.New();
transform.SetMatrix(matrix);
this.actor.SetUserTransform(transform);
}
// For reading C# matrices stored in scenario into VTK transforms
public void TransferMatrixToVTKTransform(double[][] matrix, vtkTransform transform)
{
vtkMatrix4x4 vtk_matrix = vtkMatrix4x4.New();
for (int ii = 0; ii < 4; ++ii)
{
for (int jj = 0; jj < 4; ++jj)
{
vtk_matrix.SetElement(ii, jj, matrix[ii][jj]);
}
}
transform.SetMatrix(vtk_matrix);
}
static void AlignFrames(Frame sourceFrame, Frame targetFrame, ref vtkTransform transform)
{
// This function takes two frames and finds the matrix M between them.
vtkLandmarkTransform landmarkTransform = vtkLandmarkTransform.New();
// Setup source points
vtkPoints sourcePoints = vtkPoints.New();
sourcePoints.InsertNextPoint(
sourceFrame.Origin[0],
sourceFrame.Origin[1],
sourceFrame.Origin[2]);
float[] sourceX = new float[3];
float[] sourceY = new float[3];
float[] sourceZ = new float[3];
Add(sourceFrame.Origin, sourceFrame.XDirection, ref sourceX);
Add(sourceFrame.Origin, sourceFrame.YDirection, ref sourceY);
Add(sourceFrame.Origin, sourceFrame.ZDirection, ref sourceZ);
sourcePoints.InsertNextPoint(sourceX[0], sourceX[1], sourceX[2]);
sourcePoints.InsertNextPoint(sourceY[0], sourceY[1], sourceY[2]);
sourcePoints.InsertNextPoint(sourceZ[0], sourceZ[1], sourceZ[2]);
// Setup target points
vtkPoints targetPoints = vtkPoints.New();
targetPoints.InsertNextPoint(targetFrame.Origin[0], targetFrame.Origin[1], targetFrame.Origin[2]);
float[] targetX = new float[3];
float[] targetY = new float[3];
float[] targetZ = new float[3];
Add(targetFrame.Origin, targetFrame.XDirection, ref targetX);
Add(targetFrame.Origin, targetFrame.YDirection, ref targetY);
Add(targetFrame.Origin, targetFrame.ZDirection, ref targetZ);
targetPoints.InsertNextPoint(targetX[0], targetX[1], targetX[2]);
targetPoints.InsertNextPoint(targetY[0], targetY[1], targetY[2]);
targetPoints.InsertNextPoint(targetZ[0], targetZ[1], targetZ[2]);
landmarkTransform.SetSourceLandmarks(sourcePoints);
landmarkTransform.SetTargetLandmarks(targetPoints);
landmarkTransform.SetModeToRigidBody();
landmarkTransform.Update();
vtkMatrix4x4 M = landmarkTransform.GetMatrix();
transform.SetMatrix(M);
}
public void boxInteractionCallback(vtkObject sender, vtkObjectEventArgs e)
{
vtkBoxWidget2 wid = vtkBoxWidget2.SafeDownCast(sender);
if (wid != null)
{
vtkTransform vtk_transform = vtkTransform.New();
vtkBoxRepresentation rep = (vtkBoxRepresentation)wid.GetRepresentation();
rep.GetTransform(vtk_transform);
sphereActorList[RegionsListBox.SelectedIndex].SetUserTransform(vtk_transform);
int reg_idx = RegionsListBox.SelectedIndex;
this.TransferVTKBoxWidgetTransformToMatrix(this.configurator.SimConfig.scenario.regions[reg_idx].region_box_spec);
}
}
static public vtkAlgorithmOutput genFrustumCone(double total_dis, double end_radius,
double distance, bool is_reverse)
{
vtkConeSource cone = vtkConeSource.New();
cone.SetHeight(total_dis * 1.2);
cone.SetRadius(end_radius * 1.2);
cone.SetCenter(0, 0, total_dis * 0.4);
cone.SetResolution(80);
cone.SetDirection(0, 0, 1);
cone.Update();
vtkPlane plane = vtkPlane.New();
plane.SetOrigin(0, 0, 0);
plane.SetNormal(0, 0, 1);
vtkClipPolyData clipPolyData = vtkClipPolyData.New();
clipPolyData.SetInputConnection(cone.GetOutputPort());
clipPolyData.SetClipFunction(plane);
clipPolyData.GenerateClippedOutputOn();
clipPolyData.Update();
vtkPlane plane2 = vtkPlane.New();
plane2.SetOrigin(0, 0, distance);
plane2.SetNormal(0, 0, -1);
vtkClipPolyData clipPolyData2 = vtkClipPolyData.New();
clipPolyData2.SetInputConnection(clipPolyData.GetOutputPort());
clipPolyData2.SetClipFunction(plane2);
clipPolyData2.GenerateClippedOutputOn();
clipPolyData2.Update();
if (is_reverse)
{
vtkTransform transform = vtkTransform.New();
transform.RotateWXYZ(180, 0, 1, 0);
transform.Translate(0, 0, -distance);
vtkTransformPolyDataFilter transFilter = vtkTransformPolyDataFilter.New();
transFilter.SetInputConnection(clipPolyData2.GetOutputPort());
transFilter.SetTransform(transform); //use vtkTransform (or maybe vtkLinearTransform)
transFilter.Update();
return(transFilter.GetOutputPort());
}
return(clipPolyData2.GetOutputPort());
}
//TODO
public void DrawingModeRepaint()
{
if (_lastData == null)
{
return;
}
vtkImageReslice reslice = vtkImageReslice.New();
vtkTransform transform = vtkTransform.New();
transform.PostMultiply();
//TODO wyznaczenie centrum okna
double[] center = { 75, 100, 0 };
transform.Translate(-center[0], -center[1], -center[2]);
transform.RotateZ(_orientation);
transform.Translate(+center[0], +center[1], +center[2]);
transform.Update();
reslice.SetInput(_lastData);
reslice.SetResliceTransform(transform);
reslice.Update();
vtkImageData viewerInputData;
if (!DrawingEnabled)
{
viewerInputData = reslice.GetOutput();
}
else
{
var resliceOutput = reslice.GetOutput();
var sizeArray = resliceOutput.GetDimensions();
vtkImageCanvasSource2D imageCanvas = vtkImageCanvasSource2D.New();
imageCanvas.SetScalarTypeToUnsignedChar();
imageCanvas.SetExtent(0, sizeArray[0], 0, sizeArray[1], 0, 0);
imageCanvas.DrawImage(0, 0, resliceOutput);
DrawingUtils.Draw(imageCanvas, DrawingInfo);
imageCanvas.Update();
viewerInputData = imageCanvas.GetOutput();
}
_viewer.SetInput(viewerInputData);
UpdateViewer();
}
static void AlignFrames(Frame sourceFrame, Frame targetFrame, ref vtkTransform transform)
{
// This function takes two frames and finds the matrix M between them.
vtkLandmarkTransform landmarkTransform = vtkLandmarkTransform.New();
// Setup source points
vtkPoints sourcePoints = vtkPoints.New();
sourcePoints.InsertNextPoint(
sourceFrame.Origin[0],
sourceFrame.Origin[1],
sourceFrame.Origin[2]);
float[] sourceX = new float[3];
float[] sourceY = new float[3];
float[] sourceZ = new float[3];
Add(sourceFrame.Origin, sourceFrame.XDirection, ref sourceX);
Add(sourceFrame.Origin, sourceFrame.YDirection, ref sourceY);
Add(sourceFrame.Origin, sourceFrame.ZDirection, ref sourceZ);
sourcePoints.InsertNextPoint(sourceX[0], sourceX[1], sourceX[2]);
sourcePoints.InsertNextPoint(sourceY[0], sourceY[1], sourceY[2]);
sourcePoints.InsertNextPoint(sourceZ[0], sourceZ[1], sourceZ[2]);
// Setup target points
vtkPoints targetPoints = vtkPoints.New();
targetPoints.InsertNextPoint(targetFrame.Origin[0], targetFrame.Origin[1], targetFrame.Origin[2]);
float[] targetX = new float[3];
float[] targetY = new float[3];
float[] targetZ = new float[3];
Add(targetFrame.Origin, targetFrame.XDirection, ref targetX);
Add(targetFrame.Origin, targetFrame.YDirection, ref targetY);
Add(targetFrame.Origin, targetFrame.ZDirection, ref targetZ);
targetPoints.InsertNextPoint(targetX[0], targetX[1], targetX[2]);
targetPoints.InsertNextPoint(targetY[0], targetY[1], targetY[2]);
targetPoints.InsertNextPoint(targetZ[0], targetZ[1], targetZ[2]);
landmarkTransform.SetSourceLandmarks(sourcePoints);
landmarkTransform.SetTargetLandmarks(targetPoints);
landmarkTransform.SetModeToRigidBody();
landmarkTransform.Update();
vtkMatrix4x4 M = landmarkTransform.GetMatrix();
transform.SetMatrix(M);
}
public void SetPosition(double[] position)
{
if (position == null)
{
return;
}
this.Position = position;
vtkTransform transform = vtkTransform.New();
transform.Translate(position[0], position[1], position[2]);
SetUserTransform(transform: transform);
transform.Dispose();
}
/// <summary>
/// 进行2D转换
/// </summary>
/// <param name="polyData"></param>
/// <param name="info"></param>
/// <returns></returns>
private static vtkPolyData Extrude2DSection(vtkPolyData polyData, ModelingBaseInfo info)
{
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
vtkTransformFilter transFilter = vtkTransformFilter.New();
vtkTransform transform = vtkTransform.New();
transform.RotateX(-90); // 旋转到xoy面上
transform.RotateY(info.Angle); //顺时针为正逆时针为负
// transform.Translate(info.BaseCoordinate.X, info.BaseCoordinate.Y, info.BaseCoordinate.Z);//先旋转后平移
transform.Translate(info.BaseCoordinate.X, info.BaseCoordinate.Z, info.BaseCoordinate.Y); //先旋转后平移
transFilter.SetTransform(transform);
transFilter.SetInput(polyData);
return(transFilter.GetPolyDataOutput());
}
// For storing the VTK transform generated by a box widget in a C# matrix
public void TransferVTKBoxWidgetTransformToMatrix(BoxSpecification box_spec)
{
vtkMatrix4x4 vtk_matrix = vtkMatrix4x4.New();
vtkTransform vtk_transform = vtkTransform.New();
boxRep.GetTransform(vtk_transform);
vtk_transform.GetMatrix(vtk_matrix);
for (int ii = 0; ii < 4; ++ii)
{
for (int jj = 0; jj < 4; ++jj)
{
// Using elements Set method for property change notification
box_spec.SetMatrixElement(ii, jj, vtk_matrix.GetElement(ii, jj));
}
}
}
private void Axes()
{
vtkSphereSource sphereSource = vtkSphereSource.New();
sphereSource.SetCenter(0.0, 0.0, 0.0);
sphereSource.SetRadius(0.5);
//create a mapper
vtkPolyDataMapper sphereMapper = vtkPolyDataMapper.New();
sphereMapper.SetInputConnection(sphereSource.GetOutputPort());
// create an actor
vtkActor sphereActor = vtkActor.New();
sphereActor.SetMapper(sphereMapper);
// a renderer and render window
vtkRenderWindow renderWindow = renderWindowControl1.RenderWindow;
vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
renderer.SetBackground(0.2, 0.3, 0.4);
// add the actors to the scene
renderer.AddActor(sphereActor);
vtkAxesActor axes = vtkAxesActor.New();
// The axes are positioned with a user transform
vtkTransform transform = vtkTransform.New();
transform.Translate(0.75, 0.0, 0.0);
axes.SetUserTransform(transform);
// properties of the axes labels can be set as follows
// this sets the x axis label to red
// axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(1,0,0);
// the actual text of the axis label can be changed:
// axes.SetXAxisLabelText("test");
renderer.AddActor(axes);
// we need to call Render() for the whole renderWindow,
// because vtkAxesActor uses an overlayed renderer for the axes label
// in total we have now two renderer
renderWindow.Render();
}
protected override void CalculateFilter()
{
outputType = VTK.DataType.PolyData;
vtkFilter = Kitware.VTK.vtkTransformFilter.New();
vtkTransform = Kitware.VTK.vtkTransform.New();
vtkFilter.SetInputConnection(node.parent.filter.vtkFilter.GetOutputPort());
SetTranslation();
SetRotation();
SetScale();
((vtkTransformFilter)vtkFilter).SetTransform(vtkTransform);
vtkFilter.Update();
outputType = VTK.DataType.PolyData;
}
protected override void CalculateFilter()
{
outputType = VTK.DataType.PolyData;
vtkFilter = Kitware.VTK.vtkTransformFilter.New ();
vtkTransform = Kitware.VTK.vtkTransform.New ();
vtkFilter.SetInputConnection (node.parent.filter.vtkFilter.GetOutputPort());
SetTranslation ();
SetRotation ();
SetScale ();
((vtkTransformFilter)vtkFilter).SetTransform (vtkTransform);
vtkFilter.Update ();
outputType = VTK.DataType.PolyData;
}
static public vtkProp3D genActor(List <GaussianCluster> data)
{
vtkProperty pro = new vtkProperty();
// 默认颜色
pro.SetColor(config.cone_color[0], config.cone_color[1],
config.cone_color[2]);
pro.SetOpacity(0.4);
vtkAppendPolyData polydata = vtkAppendPolyData.New();
for (int i = 1; i < data.Count; i++)
{
var cluster = data[i];
System.Windows.Forms.MessageBox.Show("cluster.start_radius:" + cluster.start_radius.ToString() +
"cluster.distance:" + cluster.distance.ToString() +
"cluster.is_foucs:" + cluster.is_foucs.ToString() +
"cluster.foucs_radius:" + cluster.foucs_radius.ToString());
vtkTransform transform = vtkTransform.New();
transform.Translate(cluster.coordinate.pos.x, cluster.coordinate.pos.y, cluster.coordinate.pos.z);
transform.RotateWXYZ(cluster.coordinate.rotate_theta, cluster.coordinate.rotate_axis.x,
cluster.coordinate.rotate_axis.y, cluster.coordinate.rotate_axis.z);
vtkTransformPolyDataFilter transFilter = vtkTransformPolyDataFilter.New();
transFilter.SetInputConnection(combiFrustumCone(cluster.start_radius,
1, cluster.angle, true, 0.01));
transFilter.SetTransform(transform);
transFilter.Update();
polydata.AddInputConnection(transFilter.GetOutputPort());
}
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(polydata.GetOutputPort());
mapper.ScalarVisibilityOff();
// The actor links the data pipeline to the rendering subsystem
vtkActor actor = vtkActor.New();
actor.SetProperty(pro);
actor.SetMapper(mapper);
return(actor);
}
/// <summary>
/// 进行二维结构的转换
/// </summary>
/// <param name="polyData"></param>
/// <param name="info"></param>
/// <returns></returns>
private static vtkActor FormActor2D(vtkPolyData polyData, ModelingBaseInfo info)
{//
vtkActor actor = vtkActor.New();
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
vtkTransformFilter transFilter = vtkTransformFilter.New();
vtkTransform transform = vtkTransform.New();
transform.RotateX(-90); // 旋转到xoy面上
transform.RotateY(info.Angle); //顺时针为正逆时针为负
transform.Translate(info.BaseCoordinate.X, info.BaseCoordinate.Y, info.BaseCoordinate.Z); //先旋转后平移
// transform.Translate(info.BaseCoordinate.X, info.BaseCoordinate.Z,info.BaseCoordinate.Y );//先旋转后平移
transFilter.SetTransform(transform);
transFilter.SetInput(polyData);
mapper.SetInputConnection(transFilter.GetOutputPort());
actor.SetMapper(mapper);
return(actor);
}
public void SetTransform(vtkMatrix4x4 matrix)
{
vtkTransform transform = vtkTransform.New();
transform.SetMatrix(matrix);
//this.lineActor.SetUserTransform(transform);
//return;
double[] linePoint1 = GetLinePoint1();
double[] linePoint2 = GetLinePoint2();
linePoint1 = xyz1;
linePoint2 = xyz2;
double[] p1 = matrix.MultiplyDoublePoint(VTKUtil.ConvertTo4P(linePoint1));
double[] p2 = matrix.MultiplyDoublePoint(VTKUtil.ConvertTo4P(linePoint2));
line.SetPoint1(p1[0], p1[1], p1[2]);
line.SetPoint2(p2[0], p2[1], p2[2]);
}
public void ReadImageIntoObject(RenderWindowControl renderWindowControl, nvmImageModel camera)
{
vtkRenderWindow renderWindow = renderWindowControl.RenderWindow;
vtkRenderer renderer = renderWindow.GetRenderers().GetFirstRenderer();
string filePath = Path.Combine(tempDirectory, $"{camera.fileName}");
vtkJPEGReader reader = vtkJPEGReader.New();
reader.SetFileName(filePath);
reader.Update();
// Treba poriesit ako nasmerovat obrazky bez pokazenia textury
var vectoris = Vector3.Transform(new Vector3(0, 0, 1), camera.quaternion);
vtkPlaneSource planeSource = vtkPlaneSource.New();
vtkTexture texture = new vtkTexture();
texture.SetInputConnection(reader.GetOutputPort());
vtkTransform transform = new vtkTransform();
transform.RotateX(180);
texture.SetTransform(transform);
vtkTextureMapToPlane plane = new vtkTextureMapToPlane();
plane.SetInputConnection(planeSource.GetOutputPort());
planeSource.SetCenter(camera.cameraCenter.X, camera.cameraCenter.Y, camera.cameraCenter.Z);
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(plane.GetOutputPort());
vtkActor actor = vtkActor.New();
actor.SetMapper(mapper);
actor.SetTexture(texture);
renderer.SetBackground(0.2, 0.3, 0.4);
renderer.AddActor(actor);
}
static public vtkAlgorithmOutput combiFrustumCone(double start_radius, double distance,
double angle, bool is_foucs, double foucs_radius)
{
double tanArc = Math.Tan(Math.PI * angle / 180);
double origin_dis = start_radius / tanArc;
if (is_foucs) // 缩小
{
double origin_foucs_dis = foucs_radius / tanArc;
double fouce_dis = origin_dis - origin_foucs_dis;
if (distance > fouce_dis) //缩小到焦点后放大
{
vtkAppendPolyData polydata = vtkAppendPolyData.New();
polydata.AddInputConnection(genFrustumCone(origin_dis, start_radius, fouce_dis, false));
vtkTransform transform = vtkTransform.New();
transform.Translate(0, 0, fouce_dis);
vtkTransformPolyDataFilter transFilter = vtkTransformPolyDataFilter.New();
origin_dis = origin_foucs_dis + distance - fouce_dis;
transFilter.SetInputConnection(genFrustumCone(origin_dis, origin_dis * tanArc, distance - fouce_dis, true));
transFilter.SetTransform(transform); //use vtkTransform (or maybe vtkLinearTransform)
transFilter.Update();
polydata.AddInputConnection(transFilter.GetOutputPort());
polydata.Update();
return(polydata.GetOutputPort());
}
else
{
return(genFrustumCone(origin_dis, start_radius, distance, false));
}
}
else // 放大
{
double total_dis = origin_dis + distance;
double end_radius = total_dis * tanArc;
return(genFrustumCone(total_dis, end_radius, distance, true));
}
}
static public vtkProp3D genCylinderActor(CompontData data, vtkProperty pro)
{
double r = data.param[0];
double h = data.param[1];
vtkCylinderSource cylinder = vtkCylinderSource.New();
cylinder.SetHeight(h);
cylinder.SetRadius(r);
cylinder.SetCenter(0, h / 2, 0);
cylinder.SetResolution(40);
cylinder.Update();
vtkTransform transform = vtkTransform.New();
transform.RotateWXYZ(90, 1, 0, 0);
vtkTransformPolyDataFilter transFilter = vtkTransformPolyDataFilter.New();
transFilter.SetInputConnection(cylinder.GetOutputPort());
transFilter.SetTransform(transform); //use vtkTransform (or maybe vtkLinearTransform)
transFilter.Update();
return(genUserActor(data, transFilter.GetOutputPort(), pro));
}
static public vtkProp3D genUserActor(CompontData data, vtkAlgorithmOutput vtkAlgorithmOutput,
vtkProperty pro)
{
vtkTransform transform = vtkTransform.New();
// 用户自定义平移旋转 (先移动后旋转)
transform.Translate(data.coor.pos.x, data.coor.pos.y, data.coor.pos.z);
transform.RotateWXYZ(data.coor.rotate_theta, data.coor.rotate_axis.x, data.coor.rotate_axis.y, data.coor.rotate_axis.z);
vtkTransformPolyDataFilter transFilter = vtkTransformPolyDataFilter.New();
transFilter.SetInputConnection(vtkAlgorithmOutput);
transFilter.SetTransform(transform); //use vtkTransform (or maybe vtkLinearTransform)
transFilter.Update();
//vtkShrinkPolyData shrink = vtkShrinkPolyData.New();
//shrink.SetInputConnection(transFilter.GetOutputPort());
//shrink.SetShrinkFactor(1);
// 改
//vtkSTLWriter writer = vtkSTLWriter.New();
//calPolyData(polyData, 0.01);
//writer.SetInputConnection(transFilter.GetOutputPort());
//writer.SetFileName("test.stl");
//writer.Update();
vtkPolyDataMapper mapper = vtkPolyDataMapper.New();
mapper.SetInputConnection(transFilter.GetOutputPort());
mapper.ScalarVisibilityOff();
// The actor links the data pipeline to the rendering subsystem
vtkActor actor = vtkActor.New();
actor.SetProperty(pro);
actor.SetMapper(mapper);
return(actor);
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVprobeComb(String [] argv)
{
//Prefix Content is: ""
// create planes[]
// Create the RenderWindow, Renderer and both Actors[]
//[]
ren1 = vtkRenderer.New();
renWin = vtkRenderWindow.New();
renWin.AddRenderer((vtkRenderer)ren1);
iren = new vtkRenderWindowInteractor();
iren.SetRenderWindow((vtkRenderWindow)renWin);
// create pipeline[]
//[]
pl3d = new vtkPLOT3DReader();
pl3d.SetXYZFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combxyz.bin");
pl3d.SetQFileName((string)"" + (VTK_DATA_ROOT.ToString()) + "/Data/combq.bin");
pl3d.SetScalarFunctionNumber((int)100);
pl3d.SetVectorFunctionNumber((int)202);
pl3d.Update();
plane = new vtkPlaneSource();
plane.SetResolution((int)50,(int)50);
transP1 = new vtkTransform();
transP1.Translate((double)3.7,(double)0.0,(double)28.37);
transP1.Scale((double)5,(double)5,(double)5);
transP1.RotateY((double)90);
tpd1 = new vtkTransformPolyDataFilter();
tpd1.SetInputConnection((vtkAlgorithmOutput)plane.GetOutputPort());
tpd1.SetTransform((vtkAbstractTransform)transP1);
outTpd1 = new vtkOutlineFilter();
outTpd1.SetInputConnection((vtkAlgorithmOutput)tpd1.GetOutputPort());
mapTpd1 = vtkPolyDataMapper.New();
mapTpd1.SetInputConnection((vtkAlgorithmOutput)outTpd1.GetOutputPort());
tpd1Actor = new vtkActor();
tpd1Actor.SetMapper((vtkMapper)mapTpd1);
tpd1Actor.GetProperty().SetColor((double)0,(double)0,(double)0);
transP2 = new vtkTransform();
transP2.Translate((double)9.2,(double)0.0,(double)31.20);
transP2.Scale((double)5,(double)5,(double)5);
transP2.RotateY((double)90);
tpd2 = new vtkTransformPolyDataFilter();
tpd2.SetInputConnection((vtkAlgorithmOutput)plane.GetOutputPort());
tpd2.SetTransform((vtkAbstractTransform)transP2);
outTpd2 = new vtkOutlineFilter();
outTpd2.SetInputConnection((vtkAlgorithmOutput)tpd2.GetOutputPort());
mapTpd2 = vtkPolyDataMapper.New();
mapTpd2.SetInputConnection((vtkAlgorithmOutput)outTpd2.GetOutputPort());
tpd2Actor = new vtkActor();
tpd2Actor.SetMapper((vtkMapper)mapTpd2);
tpd2Actor.GetProperty().SetColor((double)0,(double)0,(double)0);
transP3 = new vtkTransform();
transP3.Translate((double)13.27,(double)0.0,(double)33.30);
transP3.Scale((double)5,(double)5,(double)5);
transP3.RotateY((double)90);
tpd3 = new vtkTransformPolyDataFilter();
tpd3.SetInputConnection((vtkAlgorithmOutput)plane.GetOutputPort());
tpd3.SetTransform((vtkAbstractTransform)transP3);
outTpd3 = new vtkOutlineFilter();
outTpd3.SetInputConnection((vtkAlgorithmOutput)tpd3.GetOutputPort());
mapTpd3 = vtkPolyDataMapper.New();
mapTpd3.SetInputConnection((vtkAlgorithmOutput)outTpd3.GetOutputPort());
tpd3Actor = new vtkActor();
tpd3Actor.SetMapper((vtkMapper)mapTpd3);
tpd3Actor.GetProperty().SetColor((double)0,(double)0,(double)0);
appendF = new vtkAppendPolyData();
appendF.AddInput((vtkPolyData)tpd1.GetOutput());
appendF.AddInput((vtkPolyData)tpd2.GetOutput());
appendF.AddInput((vtkPolyData)tpd3.GetOutput());
probe = new vtkProbeFilter();
probe.SetInputConnection((vtkAlgorithmOutput)appendF.GetOutputPort());
probe.SetSource((vtkDataObject)pl3d.GetOutput());
contour = new vtkContourFilter();
contour.SetInputConnection((vtkAlgorithmOutput)probe.GetOutputPort());
contour.GenerateValues((int)50,(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
contourMapper = vtkPolyDataMapper.New();
contourMapper.SetInputConnection((vtkAlgorithmOutput)contour.GetOutputPort());
contourMapper.SetScalarRange((double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[0],
(double)((vtkDataSet)pl3d.GetOutput()).GetScalarRange()[1]);
planeActor = new vtkActor();
planeActor.SetMapper((vtkMapper)contourMapper);
outline = new vtkStructuredGridOutlineFilter();
outline.SetInputConnection((vtkAlgorithmOutput)pl3d.GetOutputPort());
outlineMapper = vtkPolyDataMapper.New();
outlineMapper.SetInputConnection((vtkAlgorithmOutput)outline.GetOutputPort());
outlineActor = new vtkActor();
outlineActor.SetMapper((vtkMapper)outlineMapper);
outlineActor.GetProperty().SetColor((double)0,(double)0,(double)0);
ren1.AddActor((vtkProp)outlineActor);
ren1.AddActor((vtkProp)planeActor);
ren1.AddActor((vtkProp)tpd1Actor);
ren1.AddActor((vtkProp)tpd2Actor);
ren1.AddActor((vtkProp)tpd3Actor);
ren1.SetBackground((double)1,(double)1,(double)1);
renWin.SetSize((int)400,(int)400);
cam1 = ren1.GetActiveCamera();
cam1.SetClippingRange((double)3.95297,(double)50);
cam1.SetFocalPoint((double)8.88908,(double)0.595038,(double)29.3342);
cam1.SetPosition((double)-12.3332,(double)31.7479,(double)41.2387);
cam1.SetViewUp((double)0.060772,(double)-0.319905,(double)0.945498);
iren.Initialize();
// prevent the tk window from showing up then start the event loop[]
//deleteAllVTKObjects();
}
// For reading C# matrices stored in scenario into VTK transforms
public void TransferMatrixToVTKTransform(double[][] matrix, vtkTransform transform)
{
vtkMatrix4x4 vtk_matrix = vtkMatrix4x4.New();
for (int ii = 0; ii < 4; ++ii)
{
for (int jj = 0; jj < 4; ++jj)
{
vtk_matrix.SetElement(ii, jj, matrix[ii][jj]);
}
}
transform.SetMatrix(vtk_matrix);
}
private void TransformAxes(vtkAxesActor axes, Position position)
{
vtkTransform transform = new vtkTransform();
transform.Translate(position.X, position.Y, position.Z);
transform.RotateWXYZ(position.A, 0, 0, 1);
transform.RotateWXYZ(position.B, 0, 1, 0);
transform.RotateWXYZ(position.C, 1, 0, 0);
axes.SetUserTransform(transform);
}
private void TransformRobotPart(vtkActor part, Position shift, Position position)
{
vtkTransform transform = new vtkTransform();
transform.Translate(position.X, position.Y, position.Z);
transform.RotateWXYZ(position.A, 0, 0, 1);
transform.RotateWXYZ(position.B, 0, 1, 0);
transform.RotateWXYZ(position.C, 1, 0, 0);
if (part == robot1part7)
transform.RotateWXYZ(11.5, 0, 0, 1);
transform.RotateWXYZ(shift.C, 1, 0, 0);
transform.RotateWXYZ(shift.B, 0, 1, 0);
transform.RotateWXYZ(shift.A, 0, 0, 1);
transform.Translate(shift.X, shift.Y, shift.Z);
part.SetUserTransform(transform);
}
/// <summary>
/// The main entry method called by the CSharp driver
/// </summary>
/// <param name="argv"></param>
public static void AVMatrixToTransform(String [] argv)
{
//Prefix Content is: ""
// This example demonstrates how to use a matrix in place of a transfrom[]
// via vtkMatrixToLinearTransform and vtkMatrixToHomogeneousTransform.[]
// create a rendering window[]
renWin = vtkRenderWindow.New();
renWin.SetSize((int)600,(int)300);
// set up first set of polydata[]
p1 = new vtkPlaneSource();
p1.SetOrigin((double)0.5,(double)0.508,(double)-0.5);
p1.SetPoint1((double)-0.5,(double)0.508,(double)-0.5);
p1.SetPoint2((double)0.5,(double)0.508,(double)0.5);
p1.SetXResolution((int)5);
p1.SetYResolution((int)5);
p2 = new vtkPlaneSource();
p2.SetOrigin((double)-0.508,(double)0.5,(double)-0.5);
p2.SetPoint1((double)-0.508,(double)-0.5,(double)-0.5);
p2.SetPoint2((double)-0.508,(double)0.5,(double)0.5);
p2.SetXResolution((int)5);
p2.SetYResolution((int)5);
p3 = new vtkPlaneSource();
p3.SetOrigin((double)-0.5,(double)-0.508,(double)-0.5);
p3.SetPoint1((double)0.5,(double)-0.508,(double)-0.5);
p3.SetPoint2((double)-0.5,(double)-0.508,(double)0.5);
p3.SetXResolution((int)5);
p3.SetYResolution((int)5);
p4 = new vtkPlaneSource();
p4.SetOrigin((double)0.508,(double)-0.5,(double)-0.5);
p4.SetPoint1((double)0.508,(double)0.5,(double)-0.5);
p4.SetPoint2((double)0.508,(double)-0.5,(double)0.5);
p4.SetXResolution((int)5);
p4.SetYResolution((int)5);
p5 = new vtkPlaneSource();
p5.SetOrigin((double)0.5,(double)0.5,(double)-0.508);
p5.SetPoint1((double)0.5,(double)-0.5,(double)-0.508);
p5.SetPoint2((double)-0.5,(double)0.5,(double)-0.508);
p5.SetXResolution((int)5);
p5.SetYResolution((int)5);
p6 = new vtkPlaneSource();
p6.SetOrigin((double)0.5,(double)0.5,(double)0.508);
p6.SetPoint1((double)-0.5,(double)0.5,(double)0.508);
p6.SetPoint2((double)0.5,(double)-0.5,(double)0.508);
p6.SetXResolution((int)5);
p6.SetYResolution((int)5);
// append together[]
ap = new vtkAppendPolyData();
ap.AddInputConnection(p1.GetOutputPort());
ap.AddInputConnection(p2.GetOutputPort());
ap.AddInputConnection(p3.GetOutputPort());
ap.AddInputConnection(p4.GetOutputPort());
ap.AddInputConnection(p5.GetOutputPort());
ap.AddInputConnection(p6.GetOutputPort());
//--------------------------[]
// linear transform matrix[]
t1 = new vtkMatrixToLinearTransform();
m1 = new vtkMatrix4x4();
t1.SetInput((vtkMatrix4x4)m1);
m1.SetElement((int)0,(int)0,(double)1.127631);
m1.SetElement((int)0,(int)1,(double)0.205212);
m1.SetElement((int)0,(int)2,(double)-0.355438);
m1.SetElement((int)1,(int)0,(double)0.000000);
m1.SetElement((int)1,(int)1,(double)0.692820);
m1.SetElement((int)1,(int)2,(double)0.400000);
m1.SetElement((int)2,(int)0,(double)0.200000);
m1.SetElement((int)2,(int)1,(double)-0.469846);
m1.SetElement((int)2,(int)2,(double)0.813798);
f11 = new vtkTransformPolyDataFilter();
f11.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f11.SetTransform((vtkAbstractTransform)t1);
m11 = new vtkDataSetMapper();
m11.SetInputConnection((vtkAlgorithmOutput)f11.GetOutputPort());
a11 = new vtkActor();
a11.SetMapper((vtkMapper)m11);
a11.GetProperty().SetColor((double)1,(double)0,(double)0);
a11.GetProperty().SetRepresentationToWireframe();
ren11 = vtkRenderer.New();
ren11.SetViewport((double)0.0,(double)0.5,(double)0.25,(double)1.0);
ren11.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren11.AddActor((vtkProp)a11);
renWin.AddRenderer((vtkRenderer)ren11);
// inverse identity transform[]
f12 = new vtkTransformPolyDataFilter();
f12.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f12.SetTransform((vtkAbstractTransform)t1.GetInverse());
m12 = new vtkDataSetMapper();
m12.SetInputConnection((vtkAlgorithmOutput)f12.GetOutputPort());
a12 = new vtkActor();
a12.SetMapper((vtkMapper)m12);
a12.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a12.GetProperty().SetRepresentationToWireframe();
ren12 = vtkRenderer.New();
ren12.SetViewport((double)0.0,(double)0.0,(double)0.25,(double)0.5);
ren12.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren12.AddActor((vtkProp)a12);
renWin.AddRenderer((vtkRenderer)ren12);
//--------------------------[]
// perspective transform matrix[]
m2 = new vtkMatrix4x4();
m2.SetElement((int)3,(int)0,(double)-0.11);
m2.SetElement((int)3,(int)1,(double)0.3);
m2.SetElement((int)3,(int)2,(double)0.2);
t2 = new vtkMatrixToHomogeneousTransform();
t2.SetInput((vtkMatrix4x4)m2);
f21 = new vtkTransformPolyDataFilter();
f21.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f21.SetTransform((vtkAbstractTransform)t2);
m21 = new vtkDataSetMapper();
m21.SetInputConnection((vtkAlgorithmOutput)f21.GetOutputPort());
a21 = new vtkActor();
a21.SetMapper((vtkMapper)m21);
a21.GetProperty().SetColor((double)1,(double)0,(double)0);
a21.GetProperty().SetRepresentationToWireframe();
ren21 = vtkRenderer.New();
ren21.SetViewport((double)0.25,(double)0.5,(double)0.50,(double)1.0);
ren21.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren21.AddActor((vtkProp)a21);
renWin.AddRenderer((vtkRenderer)ren21);
// inverse linear transform[]
f22 = new vtkTransformPolyDataFilter();
f22.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f22.SetTransform((vtkAbstractTransform)t2.GetInverse());
m22 = new vtkDataSetMapper();
m22.SetInputConnection((vtkAlgorithmOutput)f22.GetOutputPort());
a22 = new vtkActor();
a22.SetMapper((vtkMapper)m22);
a22.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a22.GetProperty().SetRepresentationToWireframe();
ren22 = vtkRenderer.New();
ren22.SetViewport((double)0.25,(double)0.0,(double)0.50,(double)0.5);
ren22.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren22.AddActor((vtkProp)a22);
renWin.AddRenderer((vtkRenderer)ren22);
//--------------------------[]
// linear concatenation - should end up with identity here[]
t3 = new vtkTransform();
t3.Concatenate((vtkLinearTransform)t1);
t3.Concatenate((vtkLinearTransform)t1.GetInverse());
f31 = new vtkTransformPolyDataFilter();
f31.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f31.SetTransform((vtkAbstractTransform)t3);
m31 = new vtkDataSetMapper();
m31.SetInputConnection((vtkAlgorithmOutput)f31.GetOutputPort());
a31 = new vtkActor();
a31.SetMapper((vtkMapper)m31);
a31.GetProperty().SetColor((double)1,(double)0,(double)0);
a31.GetProperty().SetRepresentationToWireframe();
ren31 = vtkRenderer.New();
ren31.SetViewport((double)0.50,(double)0.5,(double)0.75,(double)1.0);
ren31.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren31.AddActor((vtkProp)a31);
renWin.AddRenderer((vtkRenderer)ren31);
// inverse linear transform[]
f32 = new vtkTransformPolyDataFilter();
f32.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f32.SetTransform((vtkAbstractTransform)t3.GetInverse());
m32 = new vtkDataSetMapper();
m32.SetInputConnection((vtkAlgorithmOutput)f32.GetOutputPort());
a32 = new vtkActor();
a32.SetMapper((vtkMapper)m32);
a32.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a32.GetProperty().SetRepresentationToWireframe();
ren32 = vtkRenderer.New();
ren32.SetViewport((double)0.5,(double)0.0,(double)0.75,(double)0.5);
ren32.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren32.AddActor((vtkProp)a32);
renWin.AddRenderer((vtkRenderer)ren32);
//--------------------------[]
// perspective transform concatenation[]
t4 = new vtkPerspectiveTransform();
t4.Concatenate((vtkHomogeneousTransform)t1);
t4.Concatenate((vtkHomogeneousTransform)t2);
t4.Concatenate((vtkHomogeneousTransform)t3);
f41 = new vtkTransformPolyDataFilter();
f41.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f41.SetTransform((vtkAbstractTransform)t4);
m41 = new vtkDataSetMapper();
m41.SetInputConnection((vtkAlgorithmOutput)f41.GetOutputPort());
a41 = new vtkActor();
a41.SetMapper((vtkMapper)m41);
a41.GetProperty().SetColor((double)1,(double)0,(double)0);
a41.GetProperty().SetRepresentationToWireframe();
ren41 = vtkRenderer.New();
ren41.SetViewport((double)0.75,(double)0.5,(double)1.0,(double)1.0);
ren41.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren41.AddActor((vtkProp)a41);
renWin.AddRenderer((vtkRenderer)ren41);
// inverse of transform concatenation[]
f42 = new vtkTransformPolyDataFilter();
f42.SetInputConnection((vtkAlgorithmOutput)ap.GetOutputPort());
f42.SetTransform((vtkAbstractTransform)t4.GetInverse());
m42 = new vtkDataSetMapper();
m42.SetInputConnection((vtkAlgorithmOutput)f42.GetOutputPort());
a42 = new vtkActor();
a42.SetMapper((vtkMapper)m42);
a42.GetProperty().SetColor((double)0.9,(double)0.9,(double)0);
a42.GetProperty().SetRepresentationToWireframe();
ren42 = vtkRenderer.New();
ren42.SetViewport((double)0.75,(double)0.0,(double)1.0,(double)0.5);
ren42.ResetCamera((double)-0.5,(double)0.5,(double)-0.5,(double)0.5,(double)-1,(double)1);
ren42.AddActor((vtkProp)a42);
renWin.AddRenderer((vtkRenderer)ren42);
renWin.Render();
//deleteAllVTKObjects();
}
///<summary> A Set Method for Static Variables </summary>
public static void Sett3(vtkTransform toSet)
{
t3 = toSet;
}
///<summary> A Set Method for Static Variables </summary>
public static void SettransP3(vtkTransform toSet)
{
transP3 = toSet;
}
internal void ApplyTransform(ref vtkTransform transform, string filename)
{
vtkPolyData polydata = vtkPolyData.New();
CreatePolydata(ref polydata);
vtkTransformFilter transformFilter = vtkTransformFilter.New();
#if VTK_MAJOR_VERSION_5
transformFilter.SetInputConnection(polydata.GetProducerPort());
#else
transformFilter.SetInputData(polydata);
#endif
transformFilter.SetTransform(transform);
transformFilter.Update();
vtkXMLPolyDataWriter writer = vtkXMLPolyDataWriter.New();
writer.SetFileName(filename);
#if VTK_MAJOR_VERSION_5
writer.SetInputConnection(transformFilter.GetOutputPort());
#else
writer.SetInputData(transformFilter);
#endif
writer.Write();
}
static void myCallback(vtkObject caller, uint eventId,
object clientData, IntPtr callData)
{
System.Diagnostics.Debug.WriteLine("Callback has been called.");
if ( caller is vtkBoxWidget )
{
vtkBoxWidget boxWidget = (vtkBoxWidget) caller;
using (vtkTransform t = new vtkTransform())
{
boxWidget.GetTransform(t);
boxWidget.GetProp3D().SetUserTransform(t);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Caller is not a box widget.");
}
}
