Context Navigation

source: trunk/packages/vizservers/vtkvis/RpCutplane.cpp @ 2752

Last change on this file since 2752 was 2752, checked in by ldelgass, 13 years ago
Add outlines for cutplanes. Add commands for toggling rendering of outlines and setting outline color.
Property svn:eol-style set to `native`
File size: 23.5 KB

Line
1	/* -- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -- */
2	/*
3	* Copyright (C) 2011, Purdue Research Foundation
4	*
5	* Author: Leif Delgass <ldelgass@purdue.edu>
6	*/
7
8	#include <cassert>
9	#include <cfloat>
10	#include <cstring>
11
12	#include <vtkDataSet.h>
13	#include <vtkPointData.h>
14	#include <vtkCellData.h>
15	#include <vtkDataSetMapper.h>
16	#include <vtkUnstructuredGrid.h>
17	#include <vtkProperty.h>
18	#include <vtkImageData.h>
19	#include <vtkLookupTable.h>
20	#include <vtkTransform.h>
21	#include <vtkDelaunay2D.h>
22	#include <vtkDelaunay3D.h>
23	#include <vtkGaussianSplatter.h>
24	#include <vtkExtractVOI.h>
25	#include <vtkCutter.h>
26	#include <vtkDataSetSurfaceFilter.h>
27
28	#include "RpCutplane.h"
29	#include "RpVtkRenderer.h"
30	#include "Trace.h"
31
32	#define MESH_POINT_CLOUDS
33
34	using namespace Rappture::VtkVis;
35
36	Cutplane::Cutplane() :
37	VtkGraphicsObject(),
38	_colorMap(NULL),
39	_colorMode(COLOR_BY_SCALAR),
40	_colorFieldType(DataSet::POINT_DATA),
41	_renderer(NULL)
42	{
43	_colorFieldRange[0] = DBL_MAX;
44	_colorFieldRange[1] = -DBL_MAX;
45	}
46
47	Cutplane::~Cutplane()
48	{
49	#ifdef WANT_TRACE
50	if (_dataSet != NULL)
51	TRACE("Deleting Cutplane for %s", _dataSet->getName().c_str());
52	else
53	TRACE("Deleting Cutplane with NULL DataSet");
54	#endif
55	}
56
57	void Cutplane::setDataSet(DataSet *dataSet,
58	Renderer *renderer)
59	{
60	if (_dataSet != dataSet) {
61	_dataSet = dataSet;
62
63	_renderer = renderer;
64
65	if (renderer->getUseCumulativeRange()) {
66	renderer->getCumulativeDataRange(_dataRange,
67	_dataSet->getActiveScalarsName(),
68	1);
69	renderer->getCumulativeDataRange(_vectorMagnitudeRange,
70	_dataSet->getActiveVectorsName(),
71	3);
72	for (int i = 0; i < 3; i++) {
73	renderer->getCumulativeDataRange(_vectorComponentRange[i],
74	_dataSet->getActiveVectorsName(),
75	3, i);
76	}
77	} else {
78	_dataSet->getScalarRange(_dataRange);
79	_dataSet->getVectorRange(_vectorMagnitudeRange);
80	for (int i = 0; i < 3; i++) {
81	_dataSet->getVectorRange(_vectorComponentRange[i], i);
82	}
83	}
84
85	update();
86	}
87	}
88
89	/**
90	* \brief Create and initialize a VTK Prop to render the object
91	*/
92	void Cutplane::initProp()
93	{
94	if (_prop == NULL) {
95	_prop = vtkSmartPointer<vtkAssembly>::New();
96
97	for (int i = 0; i < 3; i++) {
98	_actor[i] = vtkSmartPointer<vtkActor>::New();
99	_borderActor[i] = vtkSmartPointer<vtkActor>::New();
100	//_actor[i]->VisibilityOff();
101	vtkProperty *property = _actor[i]->GetProperty();
102	property->SetColor(_color[0], _color[1], _color[2]);
103	property->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);
104	property->SetLineWidth(_edgeWidth);
105	property->SetPointSize(_pointSize);
106	property->EdgeVisibilityOff();
107	property->SetOpacity(_opacity);
108	property->SetAmbient(.2);
109	if (!_lighting)
110	property->LightingOff();
111	if (_faceCulling && _opacity == 1.0) {
112	setCulling(property, true);
113	}
114	property = _borderActor[i]->GetProperty();
115	property->SetColor(_color[0], _color[1], _color[2]);
116	property->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);
117	property->SetLineWidth(_edgeWidth);
118	property->SetPointSize(_pointSize);
119	property->EdgeVisibilityOff();
120	property->SetOpacity(_opacity);
121	property->SetAmbient(.2);
122	property->LightingOff();
123
124	getAssembly()->AddPart(_borderActor[i]);
125	getAssembly()->AddPart(_actor[i]);
126	}
127	}
128	}
129
130	void Cutplane::update()
131	{
132	if (_dataSet == NULL)
133	return;
134
135	vtkDataSet *ds = _dataSet->getVtkDataSet();
136
137	double bounds[6];
138	_dataSet->getBounds(bounds);
139	// Mapper, actor to render color-mapped data set
140	for (int i = 0; i < 3; i++) {
141	if (_mapper[i] == NULL) {
142	_mapper[i] = vtkSmartPointer<vtkDataSetMapper>::New();
143	// Map scalars through lookup table regardless of type
144	_mapper[i]->SetColorModeToMapScalars();
145	//_mapper->InterpolateScalarsBeforeMappingOn();
146	}
147	_cutPlane[i] = vtkSmartPointer<vtkPlane>::New();
148	switch (i) {
149	case 0:
150	_cutPlane[i]->SetNormal(1, 0, 0);
151	_cutPlane[i]->SetOrigin(bounds[0] + (bounds[1]-bounds[0])/2.,
152	0,
153	0);
154	break;
155	case 1:
156	_cutPlane[i]->SetNormal(0, 1, 0);
157	_cutPlane[i]->SetOrigin(0,
158	bounds[2] + (bounds[3]-bounds[2])/2.,
159	0);
160	break;
161	case 2:
162	default:
163	_cutPlane[i]->SetNormal(0, 0, 1);
164	_cutPlane[i]->SetOrigin(0,
165	0,
166	bounds[4] + (bounds[5]-bounds[4])/2.);
167	break;
168	}
169	_cutter[i] = vtkSmartPointer<vtkCutter>::New();
170	_cutter[i]->SetCutFunction(_cutPlane[i]);
171	}
172
173	initProp();
174
175	vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
176	if (pd &&
177	pd->GetNumberOfLines() == 0 &&
178	pd->GetNumberOfPolys() == 0 &&
179	pd->GetNumberOfStrips() == 0) {
180	// DataSet is a point cloud
181	PrincipalPlane plane;
182	double offset;
183	if (_dataSet->is2D(&plane, &offset)) {
184	// DataSet is a 2D point cloud
185	#ifdef MESH_POINT_CLOUDS
186	vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
187	if (plane == PLANE_ZY) {
188	vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
189	trans->RotateWXYZ(90, 0, 1, 0);
190	if (offset != 0.0) {
191	trans->Translate(-offset, 0, 0);
192	}
193	mesher->SetTransform(trans);
194	_actor[1]->VisibilityOff();
195	_actor[2]->VisibilityOff();
196	} else if (plane == PLANE_XZ) {
197	vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
198	trans->RotateWXYZ(-90, 1, 0, 0);
199	if (offset != 0.0) {
200	trans->Translate(0, -offset, 0);
201	}
202	mesher->SetTransform(trans);
203	_actor[0]->VisibilityOff();
204	_actor[2]->VisibilityOff();
205	} else if (offset != 0.0) {
206	// XY with Z offset
207	vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
208	trans->Translate(0, 0, -offset);
209	mesher->SetTransform(trans);
210	_actor[0]->VisibilityOff();
211	_actor[1]->VisibilityOff();
212	}
213	mesher->SetInput(pd);
214	for (int i = 0; i < 3; i++) {
215	_mapper[i]->SetInputConnection(mesher->GetOutputPort());
216	}
217	#else
218	vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
219	splatter->SetInput(pd);
220	int dims[3];
221	splatter->GetSampleDimensions(dims);
222	TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
223	if (plane == DataSet::PLANE_ZY) {
224	dims[0] = 3;
225	} else if (plane == DataSet::PLANE_XZ) {
226	dims[1] = 3;
227	} else {
228	dims[2] = 3;
229	}
230	splatter->SetSampleDimensions(dims);
231	for (int i = 0; i < 3; i++) {
232	_cutter[i]->SetInputConnection(splatter->GetOutputPort());
233	vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
234	gf->UseStripsOn();
235	gf->SetInputConnection(_cutter[i]->GetOutputPort());
236	_mapper[i]->SetInputConnection(gf->GetOutputPort());
237	}
238	#endif
239	} else {
240	#ifdef MESH_POINT_CLOUDS
241	// Data Set is a 3D point cloud
242	// Result of Delaunay3D mesher is unstructured grid
243	vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
244	mesher->SetInput(pd);
245	// Sample a plane within the grid bounding box
246	for (int i = 0; i < 3; i++) {
247	_cutter[i]->SetInputConnection(mesher->GetOutputPort());
248	vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
249	gf->UseStripsOn();
250	gf->SetInputConnection(_cutter[i]->GetOutputPort());
251	_mapper[i]->SetInputConnection(gf->GetOutputPort());
252	}
253	#else
254	vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
255	splatter->SetInput(pd);
256	int dims[3];
257	splatter->GetSampleDimensions(dims);
258	TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
259	for (int i = 0; i < 3; i++) {
260	_cutter[i]->SetInputConnection(splatter->GetOutputPort());
261	vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
262	gf->UseStripsOn();
263	gf->SetInputConnection(_cutter[i]->GetOutputPort());
264	_mapper[i]->SetInputConnection(gf->GetOutputPort());
265	}
266	#endif
267	}
268	} else {
269	// DataSet can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid, or
270	// PolyData with cells other than points
271	PrincipalPlane plane;
272	double offset;
273	if (!_dataSet->is2D(&plane, &offset)) {
274	// Sample a plane within the grid bounding box
275	for (int i = 0; i < 3; i++) {
276	_cutter[i]->SetInput(ds);
277	vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
278	gf->UseStripsOn();
279	gf->SetInputConnection(_cutter[i]->GetOutputPort());
280	_mapper[i]->SetInputConnection(gf->GetOutputPort());
281	}
282	} else {
283	// 2D data
284	if (plane == PLANE_ZY) {
285	_actor[1]->VisibilityOff();
286	_actor[2]->VisibilityOff();
287	} else if (plane == PLANE_XZ) {
288	_actor[0]->VisibilityOff();
289	_actor[2]->VisibilityOff();
290	} else if (offset != 0.0) {
291	// XY with Z offset
292	_actor[0]->VisibilityOff();
293	_actor[1]->VisibilityOff();
294	}
295	for (int i = 0; i < 3; i++) {
296	vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
297	gf->UseStripsOn();
298	gf->SetInput(ds);
299	_mapper[i]->SetInputConnection(gf->GetOutputPort());
300	}
301	}
302	}
303
304	for (int i = 0; i < 3; i++) {
305	if (_mapper[i] != NULL) {
306	_borderMapper[i] = vtkSmartPointer<vtkPolyDataMapper>::New();
307	_outlineFilter[i] = vtkSmartPointer<vtkOutlineFilter>::New();
308	_outlineFilter[i]->SetInputConnection(_mapper[i]->GetInputConnection(0, 0));
309	_borderMapper[i]->SetInputConnection(_outlineFilter[i]->GetOutputPort());
310	}
311	}
312
313	if (_lut == NULL) {
314	setColorMap(ColorMap::getDefault());
315	}
316
317	setColorMode(_colorMode);
318
319	for (int i = 0; i < 3; i++) {
320	if (_mapper[i] != NULL) {
321	_actor[i]->SetMapper(_mapper[i]);
322	_mapper[i]->Update();
323	}
324	if (_borderMapper[i] != NULL) {
325	_borderActor[i]->SetMapper(_borderMapper[i]);
326	_borderMapper[i]->Update();
327	}
328	}
329	}
330
331	/**
332	* \brief Select a 2D slice plane from a 3D DataSet
333	*
334	* \param[in] axis Axis of slice plane
335	* \param[in] ratio Position [0,1] of slice plane along axis
336	*/
337	void Cutplane::selectVolumeSlice(Axis axis, double ratio)
338	{
339	if (_dataSet->is2D()) {
340	WARN("DataSet not 3D, returning");
341	return;
342	}
343
344	if ((axis == X_AXIS &&_cutPlane[0] == NULL) \|\|
345	(axis == Y_AXIS &&_cutPlane[1] == NULL) \|\|
346	(axis == Z_AXIS &&_cutPlane[2] == NULL)) {
347	WARN("Called before update() or DataSet is not a volume");
348	return;
349	}
350
351	double bounds[6];
352	_dataSet->getBounds(bounds);
353	switch (axis) {
354	case X_AXIS:
355	_cutPlane[0]->SetOrigin(bounds[0] + (bounds[1]-bounds[0]) * ratio,
356	0,
357	0);
358	if (_mapper[0] != NULL)
359	_mapper[0]->Update();
360	break;
361	case Y_AXIS:
362	_cutPlane[1]->SetOrigin(0,
363	bounds[2] + (bounds[3]-bounds[2]) * ratio,
364	0);
365	if (_mapper[1] != NULL)
366	_mapper[1]->Update();
367	break;
368	case Z_AXIS:
369	_cutPlane[2]->SetOrigin(0,
370	0,
371	bounds[4] + (bounds[5]-bounds[4]) * ratio);
372	if (_mapper[2] != NULL)
373	_mapper[2]->Update();
374	break;
375	default:
376	ERROR("Invalid Axis");
377	return;
378	}
379	}
380
381	void Cutplane::updateRanges(Renderer *renderer)
382	{
383	if (_dataSet == NULL) {
384	ERROR("called before setDataSet");
385	return;
386	}
387
388	if (renderer->getUseCumulativeRange()) {
389	renderer->getCumulativeDataRange(_dataRange,
390	_dataSet->getActiveScalarsName(),
391	1);
392	renderer->getCumulativeDataRange(_vectorMagnitudeRange,
393	_dataSet->getActiveVectorsName(),
394	3);
395	for (int i = 0; i < 3; i++) {
396	renderer->getCumulativeDataRange(_vectorComponentRange[i],
397	_dataSet->getActiveVectorsName(),
398	3, i);
399	}
400	} else {
401	_dataSet->getScalarRange(_dataRange);
402	_dataSet->getVectorRange(_vectorMagnitudeRange);
403	for (int i = 0; i < 3; i++) {
404	_dataSet->getVectorRange(_vectorComponentRange[i], i);
405	}
406	}
407
408	// Need to update color map ranges
409	double *rangePtr = _colorFieldRange;
410	if (_colorFieldRange[0] > _colorFieldRange[1]) {
411	rangePtr = NULL;
412	}
413	setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
414	}
415
416	void Cutplane::setColorMode(ColorMode mode)
417	{
418	_colorMode = mode;
419	if (_dataSet == NULL)
420	return;
421
422	switch (mode) {
423	case COLOR_BY_SCALAR:
424	setColorMode(mode,
425	_dataSet->getActiveScalarsType(),
426	_dataSet->getActiveScalarsName(),
427	_dataRange);
428	break;
429	case COLOR_BY_VECTOR_MAGNITUDE:
430	setColorMode(mode,
431	_dataSet->getActiveVectorsType(),
432	_dataSet->getActiveVectorsName(),
433	_vectorMagnitudeRange);
434	break;
435	case COLOR_BY_VECTOR_X:
436	setColorMode(mode,
437	_dataSet->getActiveVectorsType(),
438	_dataSet->getActiveVectorsName(),
439	_vectorComponentRange[0]);
440	break;
441	case COLOR_BY_VECTOR_Y:
442	setColorMode(mode,
443	_dataSet->getActiveVectorsType(),
444	_dataSet->getActiveVectorsName(),
445	_vectorComponentRange[1]);
446	break;
447	case COLOR_BY_VECTOR_Z:
448	setColorMode(mode,
449	_dataSet->getActiveVectorsType(),
450	_dataSet->getActiveVectorsName(),
451	_vectorComponentRange[2]);
452	break;
453	default:
454	;
455	}
456	}
457
458	void Cutplane::setColorMode(ColorMode mode,
459	const char *name, double range[2])
460	{
461	if (_dataSet == NULL)
462	return;
463	DataSet::DataAttributeType type;
464	int numComponents;
465	if (!_dataSet->getFieldInfo(name, &type, &numComponents)) {
466	ERROR("Field not found: %s", name);
467	return;
468	}
469	setColorMode(mode, type, name, range);
470	}
471
472	void Cutplane::setColorMode(ColorMode mode,
473	DataSet::DataAttributeType type,
474	const char *name, double range[2])
475	{
476	_colorMode = mode;
477	_colorFieldType = type;
478	if (name == NULL)
479	_colorFieldName.clear();
480	else
481	_colorFieldName = name;
482	if (range == NULL) {
483	_colorFieldRange[0] = DBL_MAX;
484	_colorFieldRange[1] = -DBL_MAX;
485	} else {
486	memcpy(_colorFieldRange, range, sizeof(double)*2);
487	}
488
489	if (_dataSet == NULL \|\|
490	_mapper[0] == NULL \|\|
491	_mapper[1] == NULL \|\|
492	_mapper[2] == NULL)
493	return;
494
495	switch (type) {
496	case DataSet::POINT_DATA:
497	for (int i = 0; i < 3; i++) {
498	_mapper[i]->SetScalarModeToUsePointFieldData();
499	}
500	break;
501	case DataSet::CELL_DATA:
502	for (int i = 0; i < 3; i++) {
503	_mapper[i]->SetScalarModeToUseCellFieldData();
504	}
505	break;
506	default:
507	ERROR("Unsupported DataAttributeType: %d", type);
508	return;
509	}
510
511	if (name != NULL && strlen(name) > 0) {
512	for (int i = 0; i < 3; i++) {
513	_mapper[i]->SelectColorArray(name);
514	}
515	} else {
516	for (int i = 0; i < 3; i++) {
517	_mapper[i]->SetScalarModeToDefault();
518	}
519	}
520
521	if (_lut != NULL) {
522	if (range != NULL) {
523	_lut->SetRange(range);
524	} else if (name != NULL && strlen(name) > 0) {
525	double r[2];
526	int comp = -1;
527	if (mode == COLOR_BY_VECTOR_X)
528	comp = 0;
529	else if (mode == COLOR_BY_VECTOR_Y)
530	comp = 1;
531	else if (mode == COLOR_BY_VECTOR_Z)
532	comp = 2;
533
534	if (_renderer->getUseCumulativeRange()) {
535	int numComponents;
536	if (!_dataSet->getFieldInfo(name, type, &numComponents)) {
537	ERROR("Field not found: %s, type: %d", name, type);
538	return;
539	} else if (numComponents < comp+1) {
540	ERROR("Request for component %d in field with %d components",
541	comp, numComponents);
542	return;
543	}
544	_renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
545	} else {
546	_dataSet->getDataRange(r, name, type, comp);
547	}
548	_lut->SetRange(r);
549	}
550	}
551
552
553	switch (mode) {
554	case COLOR_BY_SCALAR:
555	for (int i = 0; i < 3; i++) {
556	_mapper[i]->ScalarVisibilityOn();
557	}
558	break;
559	case COLOR_BY_VECTOR_MAGNITUDE:
560	for (int i = 0; i < 3; i++) {
561	_mapper[i]->ScalarVisibilityOn();
562	}
563	if (_lut != NULL) {
564	_lut->SetVectorModeToMagnitude();
565	}
566	break;
567	case COLOR_BY_VECTOR_X:
568	for (int i = 0; i < 3; i++) {
569	_mapper[i]->ScalarVisibilityOn();
570	}
571	if (_lut != NULL) {
572	_lut->SetVectorModeToComponent();
573	_lut->SetVectorComponent(0);
574	}
575	break;
576	case COLOR_BY_VECTOR_Y:
577	for (int i = 0; i < 3; i++) {
578	_mapper[i]->ScalarVisibilityOn();
579	}
580	if (_lut != NULL) {
581	_lut->SetVectorModeToComponent();
582	_lut->SetVectorComponent(1);
583	}
584	break;
585	case COLOR_BY_VECTOR_Z:
586	for (int i = 0; i < 3; i++) {
587	_mapper[i]->ScalarVisibilityOn();
588	}
589	if (_lut != NULL) {
590	_lut->SetVectorModeToComponent();
591	_lut->SetVectorComponent(2);
592	}
593	break;
594	default:
595	for (int i = 0; i < 3; i++) {
596	_mapper[i]->ScalarVisibilityOff();
597	}
598	break;
599	}
600	}
601
602	/**
603	* \brief Called when the color map has been edited
604	*/
605	void Cutplane::updateColorMap()
606	{
607	setColorMap(_colorMap);
608	}
609
610	/**
611	* \brief Associate a colormap lookup table with the DataSet
612	*/
613	void Cutplane::setColorMap(ColorMap *cmap)
614	{
615	if (cmap == NULL)
616	return;
617
618	_colorMap = cmap;
619
620	if (_lut == NULL) {
621	_lut = vtkSmartPointer<vtkLookupTable>::New();
622	for (int i = 0; i < 3; i++) {
623	if (_mapper[i] != NULL) {
624	_mapper[i]->UseLookupTableScalarRangeOn();
625	_mapper[i]->SetLookupTable(_lut);
626	}
627	}
628	_lut->DeepCopy(cmap->getLookupTable());
629	switch (_colorMode) {
630	case COLOR_BY_SCALAR:
631	_lut->SetRange(_dataRange);
632	break;
633	case COLOR_BY_VECTOR_MAGNITUDE:
634	_lut->SetRange(_vectorMagnitudeRange);
635	break;
636	case COLOR_BY_VECTOR_X:
637	_lut->SetRange(_vectorComponentRange[0]);
638	break;
639	case COLOR_BY_VECTOR_Y:
640	_lut->SetRange(_vectorComponentRange[1]);
641	break;
642	case COLOR_BY_VECTOR_Z:
643	_lut->SetRange(_vectorComponentRange[2]);
644	break;
645	default:
646	break;
647	}
648	} else {
649	double range[2];
650	_lut->GetTableRange(range);
651	_lut->DeepCopy(cmap->getLookupTable());
652	_lut->SetRange(range);
653	}
654
655	switch (_colorMode) {
656	case COLOR_BY_VECTOR_MAGNITUDE:
657	_lut->SetVectorModeToMagnitude();
658	break;
659	case COLOR_BY_VECTOR_X:
660	_lut->SetVectorModeToComponent();
661	_lut->SetVectorComponent(0);
662	break;
663	case COLOR_BY_VECTOR_Y:
664	_lut->SetVectorModeToComponent();
665	_lut->SetVectorComponent(1);
666	break;
667	case COLOR_BY_VECTOR_Z:
668	_lut->SetVectorModeToComponent();
669	_lut->SetVectorComponent(2);
670	break;
671	default:
672	break;
673	}
674	}
675
676	/**
677	* \brief Turn on/off lighting of this object
678	*/
679	void Cutplane::setLighting(bool state)
680	{
681	_lighting = state;
682	for (int i = 0; i < 3; i++) {
683	if (_actor[i] != NULL)
684	_actor[i]->GetProperty()->SetLighting((state ? 1 : 0));
685	}
686	}
687
688	/**
689	* \brief Turn on/off rendering of mesh edges
690	*/
691	void Cutplane::setEdgeVisibility(bool state)
692	{
693	for (int i = 0; i < 3; i++) {
694	if (_actor[i] != NULL) {
695	_actor[i]->GetProperty()->SetEdgeVisibility((state ? 1 : 0));
696	}
697	}
698	}
699
700	/**
701	* \brief Turn on/off rendering of outlines
702	*/
703	void Cutplane::setOutlineVisibility(bool state)
704	{
705	for (int i = 0; i < 3; i++) {
706	if (_borderActor[i] != NULL) {
707	_borderActor[i]->SetVisibility((state ? 1 : 0));
708	}
709	}
710	}
711
712	/**
713	* \brief Set visibility of cutplane on specified axis
714	*/
715	void Cutplane::setSliceVisibility(Axis axis, bool state)
716	{
717	switch (axis) {
718	case X_AXIS:
719	if (_actor[0] != NULL)
720	_actor[0]->SetVisibility((state ? 1 : 0));
721	if (_borderActor[0] != NULL)
722	_borderActor[0]->SetVisibility((state ? 1 : 0));
723	break;
724	case Y_AXIS:
725	if (_actor[1] != NULL)
726	_actor[1]->SetVisibility((state ? 1 : 0));
727	if (_borderActor[1] != NULL)
728	_borderActor[1]->SetVisibility((state ? 1 : 0));
729	break;
730	case Z_AXIS:
731	default:
732	if (_actor[2] != NULL)
733	_actor[2]->SetVisibility((state ? 1 : 0));
734	if (_borderActor[2] != NULL)
735	_borderActor[2]->SetVisibility((state ? 1 : 0));
736	break;
737	}
738	}
739
740	/**
741	* \brief Set a group of world coordinate planes to clip rendering
742	*
743	* Passing NULL for planes will remove all cliping planes
744	*/
745	void Cutplane::setClippingPlanes(vtkPlaneCollection *planes)
746	{
747	for (int i = 0; i < 3; i++) {
748	if (_mapper[i] != NULL) {
749	_mapper[i]->SetClippingPlanes(planes);
750	}
751	}
752	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: