Context Navigation

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

Last change on this file since 3177 was 3177, checked in by mmc, 12 years ago
Updated all of the copyright notices to reference the transfer to the new HUBzero Foundation, LLC.
Property svn:eol-style set to `native`
File size: 24.2 KB

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

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

Download in other formats: