Exemplo n.º 1
0
DoubleRange DoublePropertyImageTFDataWindow::getValueRange() const
{
  if (!mImage)
    return DoubleRange();
  double range = mImage->getMax() - mImage->getMin();
  return DoubleRange(1,range,range/1000.0);
}
Exemplo n.º 2
0
DoubleRange DoublePropertyImageTFDataAlpha::getValueRange() const
{
  if (!mImageTFData)
    return DoubleRange();

  double max = 1.0;
  return DoubleRange(0,max,max/100.0);
}
Exemplo n.º 3
0
DoubleRange DoublePropertyImageTFDataLevel::getValueRange() const
{
  if (!mImageTFData)
    return DoubleRange();

  double max = mImage->getMax();
  double min = mImage->getMin();
  return DoubleRange(min,max,1);
}
Exemplo n.º 4
0
DoubleRange DoublePropertyImageTFDataLLR::getValueRange() const
{
  if (!mImageTFData)
    return DoubleRange();

  double max = mImage->getMax();
  double min = mImage->getMin();
	//Set range to min - 1 to allow an llr that shows all values
	return DoubleRange(min - 1,max,(max-min)/1000.0);
}
void BronchoscopyRegistrationWidget::createMaxLocalRegistrationDistance(QDomElement root)
{
	mMaxLocalRegistrationDistance = DoubleProperty::initialize("Max local registration distance (mm)", "",
	"Set max distance for local registration in mm", 30, DoubleRange(1, 200, 1), 0,
					root);
	mMaxLocalRegistrationDistance->setGuiRepresentation(DoubleProperty::grSLIDER);
}
void BronchoscopyRegistrationWidget::createMaxNumberOfGenerations(QDomElement root)
{
	mMaxNumberOfGenerations = DoubleProperty::initialize("Max number of generations in centerline", "",
	"Set max number of generations centerline", 4, DoubleRange(0, 10, 1), 0,
					root);
	mMaxNumberOfGenerations->setGuiRepresentation(DoublePropertyBase::grSLIDER);
}
Exemplo n.º 7
0
DoublePropertyPtr AirwaysFilter::getNoiseLevelOption(QDomElement root)
{
	DoublePropertyPtr retval = DoubleProperty::initialize("Noise level",
			"", "Select the amount of noise present in the image", 0.5,
			DoubleRange(0.0, 2, 0.5), 1, root);
	retval->setGuiRepresentation(DoubleProperty::grSLIDER);
	return retval;
}
Exemplo n.º 8
0
DoublePropertyPtr DilationFilter::getDilationRadiusOption(QDomElement root)
{
	DoublePropertyPtr retval = DoubleProperty::initialize("Dilation radius (mm)", "",
    "Set dilation radius in mm", 1, DoubleRange(1, 20, 1), 0,
                    root);
	retval->setGuiRepresentation(DoublePropertyBase::grSLIDER);
	return retval;
}
Exemplo n.º 9
0
DoublePropertyPtr AirwaysFilter::getSensitivityOption(QDomElement root)
{
	DoublePropertyPtr retval = DoubleProperty::initialize("Sensitivity",
			"", "Select sensitivity for the segmentation", 0.85,
			DoubleRange(0.01, 1, 0.01), 2, root);
	retval->setGuiRepresentation(DoubleProperty::grSLIDER);
	return retval;

}
Exemplo n.º 10
0
void EraserWidget::activeImageChangedSlot()
{
	ImagePtr image = mPatientModelService->getActiveImage();
	if(!image)
		return;

	mEraseValueAdapter->setValueRange(DoubleRange(image->getVTKMinValue(), image->getVTKMaxValue(), 1));
	mEraseValueAdapter->setValue(image->getMin());
}
Exemplo n.º 11
0
void FilterImpl::updateThresholdPairFromImageChange(QString uid, DoublePairPropertyPtr threshold)
{
	ImagePtr image = mServices->patient()->getData<Image>(uid);
	if(!image)
		return;
	threshold->setValueRange(DoubleRange(image->getMin(), image->getMax(), 1));

	int initLower = ::ceil(double(image->getMin()) + double(image->getRange())/10); // round up
	int initUpper = image->getMax();
	threshold->setValue(Eigen::Vector2d(initLower, initUpper));
}
Exemplo n.º 12
0
DoublePropertyBasePtr NetworkConnectionHandle::createPortOption()
{
	DoublePropertyPtr retval;
	int defval = mClient->getConnectionInfo().port;
	retval = DoubleProperty::initialize("port", "Port",
										"Network Port (default "+QString::number(defval)+")",
										defval,
										DoubleRange(1024, 49151, 1), 0,
										mOptions.getElement());
	retval->setGuiRepresentation(DoublePropertyBase::grSPINBOX);
	retval->setAdvanced(true);
	retval->setGroup("Connection");
	connect(retval.get(), &Property::changed, this, &NetworkConnectionHandle::onPropertiesChanged);
	return retval;
}
Exemplo n.º 13
0
void FilterImpl::updateThresholdFromImageChange(QString uid, DoublePropertyPtr threshold)
{
	ImagePtr image = mServices->patient()->getData<Image>(uid);
	if(!image)
		return;
	threshold->setValueRange(DoubleRange(image->getMin(), image->getMax(), 1));
	int oldLower = threshold->getValue();
	// avoid reset if old value is still within range,
	// but reset anyway if old val is 0..1, this can indicate old image was binary.
	if ((image->getMin() > oldLower )||( oldLower > image->getMax() )||( oldLower<=1 ))
	{
		int initLower = ::ceil(double(image->getMin()) + double(image->getRange())/10); // round up
		threshold->setValue(initLower);
	}
//	std::cout << "FilterImpl::imageChangedSlot " << image->getMin() << " "  << image->getMax() << std::endl;
//	std::cout << "            imageChangedSlot() " << threshold->getValue() << std::endl;
}
Exemplo n.º 14
0
void Transform3DWidget::addTranslationControls(QString uid, QString name, int index, QVBoxLayout* layout)
{
  QHBoxLayout* hLayout = new QHBoxLayout;

  DoublePropertyPtr adapter = DoubleProperty::initialize(uid, name, "", 0, DoubleRange(-10000,10000,0.1),1);
  connect(adapter.get(), SIGNAL(changed()), this, SLOT(changedSlot()));
  adapter->setInternal2Display(1.0);
  hLayout->addWidget(new SpinBoxGroupWidget(this, adapter));

  QSize mMinBarSize = QSize(20,20);
  MousePadWidget* pad = new MousePadWidget(this, mMinBarSize);
  pad->setFixedYPos(true);
  hLayout->addWidget(pad);

  // use QtSignalAdapters library to work magic:
  QtSignalAdapters::connect1<void(QPointF)>(pad, SIGNAL(mouseMoved(QPointF)),
      boost::bind(&Transform3DWidget::translateSlot, this, _1, index));

  layout->addLayout(hLayout);
  mTranslationAdapter[index] = adapter;
}
Exemplo n.º 15
0
void VisualizationTab::init()
{
  double sphereRadius = settings()->value("View3D/sphereRadius").toDouble();
  mSphereRadius = DoubleProperty::initialize("SphereRadius", "Sphere Radius", "Radius of sphere markers in the 3D scene.", sphereRadius, DoubleRange(0.1,10,0.1), 1, QDomNode());

  double labelSize = settings()->value("View3D/labelSize").toDouble();
  mLabelSize = DoubleProperty::initialize("LabelSize", "Label Size", "Size of text labels in the 3D scene.", labelSize, DoubleRange(0.1,100,0.1), 1, QDomNode());

  ColorSelectButton* backgroundColorButton = new ColorSelectButton("Background Color");
  backgroundColorButton->setColor(settings()->value("backgroundColor").value<QColor>());

  connect(backgroundColorButton, SIGNAL(colorChanged(QColor)), this, SLOT(setBackgroundColorSlot(QColor)));

  bool showDataText = settings()->value("View/showDataText").value<bool>();
  mShowDataText = BoolProperty::initialize("Show Data Text", "",
                                                 "Show the name of each data set in the views.",
                                                 showDataText);
  bool showLabels = settings()->value("View/showLabels").value<bool>();
  mShowLabels = BoolProperty::initialize("Show Labels", "",
                                                 "Attach name labels to entities in the views.",
                                                 showLabels);

  bool showMetricNamesInCorner = settings()->value("View/showMetricNamesInCorner").value<bool>();
  mShowMetricNamesInCorner = BoolProperty::initialize("Corner Metrics", "",
												 "Show the metric data in the upper right corner of the view instead of in the scene.",
												 showMetricNamesInCorner);


  double annotationModelSize = settings()->value("View3D/annotationModelSize").toDouble();
  mAnnotationModelSize = DoubleProperty::initialize("AnnotationModelSize", "Annotation Model Size", "Size (0..1) of the annotation model in the 3D scene.", annotationModelSize, DoubleRange(0.01,1,0.01), 2, QDomNode());
  QStringList annotationModelRange;
  foreach(QString path, DataLocations::getRootConfigPaths())
  {
	  annotationModelRange << QDir(path+"/models/").entryList(QStringList()<<"*.stl");
  }
Exemplo n.º 16
0
void VisualizationTab::init()
{
  double sphereRadius = settings()->value("View3D/sphereRadius").toDouble();
  mSphereRadius = DoubleProperty::initialize("SphereRadius", "Sphere Radius", "Radius of sphere markers in the 3D scene.", sphereRadius, DoubleRange(0.1,10,0.1), 1, QDomNode());

  double labelSize = settings()->value("View3D/labelSize").toDouble();
  mLabelSize = DoubleProperty::initialize("LabelSize", "Label Size", "Size of text labels in the 3D scene.", labelSize, DoubleRange(0.1,100,0.1), 1, QDomNode());

  SelectColorSettingButton* backgroundColorButton =
		  new SelectColorSettingButton("Background Color",
									   "backgroundColor",
									   "Set 3D view background color");

  SelectColorSettingButton* tool2DColor =
		  new SelectColorSettingButton("Tool Color 2D",
									   "View2D/toolColor",
									   "Set the color of the tool in 2D");
  SelectColorSettingButton* toolTipPointColor =
		  new SelectColorSettingButton("Tool Tip 2D/3D",
									   "View/toolTipPointColor",
									   "Set the color of the tool tip in 2D/3D");
  SelectColorSettingButton* toolOffsetPointColor =
		  new SelectColorSettingButton("Offset Point 2D/3D",
									   "View/toolOffsetPointColor",
									   "Set the color of the tool offset point in 2D/3D");
  SelectColorSettingButton* toolOffsetLineColor =
		  new SelectColorSettingButton("Offset Line 2D/3D",
									   "View/toolOffsetLineColor",
									   "Set the color of the tool offset line in 2D/3D");
  SelectColorSettingButton* toolCrossHairColor =
		  new SelectColorSettingButton("Crosshair 2D",
									   "View2D/toolCrossHairColor",
									   "Set the color of the tool 2D crosshair");

  bool showDataText = settings()->value("View/showDataText").value<bool>();
  mShowDataText = BoolProperty::initialize("Show Data Text", "",
                                                 "Show the name of each data set in the views.",
                                                 showDataText);
  bool showLabels = settings()->value("View/showLabels").value<bool>();
  mShowLabels = BoolProperty::initialize("Show Labels", "",
                                                 "Attach name labels to entities in the views.",
                                                 showLabels);

  bool toolCrosshair = settings()->value("View2D/showToolCrosshair").value<bool>();
  mToolCrosshair = BoolProperty::initialize("Tool 2D Crosshair", "",
										 "Show a crosshair centered on the tool in the orthogonal (ACS) views.",
										 toolCrosshair);


  bool showMetricNamesInCorner = settings()->value("View/showMetricNamesInCorner").value<bool>();
  mShowMetricNamesInCorner = BoolProperty::initialize("Corner Metrics", "",
												 "Show the metric data in the upper right corner of the view instead of in the scene.",
												 showMetricNamesInCorner);


  double annotationModelSize = settings()->value("View3D/annotationModelSize").toDouble();
  mAnnotationModelSize = DoubleProperty::initialize("AnnotationModelSize", "Annotation Model Size", "Size (0..1) of the annotation model in the 3D scene.", annotationModelSize, DoubleRange(0.01,1,0.01), 2, QDomNode());
  QStringList annotationModelRange;
  foreach(QString path, DataLocations::getRootConfigPaths())
  {
	  annotationModelRange << QDir(path+"/models/").entryList(QStringList()<<"*.stl");
  }
Exemplo n.º 17
0
EraserWidget::EraserWidget(PatientModelServicePtr patientModelService, VisualizationServicePtr visualizationService, QWidget* parent) :
	BaseWidget(parent, "EraserWidget", "Eraser"),
	mPreviousCenter(0,0,0),
	mPreviousRadius(0),
	mActiveImageProxy(ActiveImageProxyPtr()),
	mPatientModelService(patientModelService),
	mVisualizationService(visualizationService)

{

	QVBoxLayout* layout = new QVBoxLayout(this);
	this->setToolTip("Erase parts of volumes/models");

	mContinousEraseTimer = new QTimer(this);
	connect(mContinousEraseTimer, SIGNAL(timeout()), this, SLOT(continousRemoveSlot())); // this signal will be executed in the thread of THIS, i.e. the main thread.

	QHBoxLayout* buttonLayout = new QHBoxLayout;
	layout->addLayout(buttonLayout);
	QHBoxLayout* buttonLayout2 = new QHBoxLayout;
	layout->addLayout(buttonLayout2);

	mShowEraserCheckBox = new QCheckBox("Show");
	mShowEraserCheckBox->setToolTip("Show eraser sphere in the views.");
	connect(mShowEraserCheckBox, SIGNAL(toggled(bool)), this, SLOT(toggleShowEraser(bool)));
	buttonLayout->addWidget(mShowEraserCheckBox);

	mContinousEraseCheckBox = new QCheckBox("Continous");
	mContinousEraseCheckBox->setToolTip("Erase continously using the sphere. (might be slow)");
	connect(mContinousEraseCheckBox, SIGNAL(toggled(bool)), this, SLOT(toggleContinous(bool)));
	buttonLayout2->addWidget(mContinousEraseCheckBox);

	mDuplicateAction = this->createAction(this, QIcon(), "Duplicate", "Duplicate active volume - do this before erasing!",
		SLOT(duplicateSlot()), buttonLayout);

	mSaveAction = this->createAction(this, QIcon(), "Save", "Save modified image to disk",
		SLOT(saveSlot()), buttonLayout);

	mRemoveAction = this->createAction(this, QIcon(), "Erase", "Erase everything inside sphere",
		SLOT(removeSlot()), buttonLayout2);


	double sphereRadius = 10;
	mSphereSizeAdapter = DoubleProperty::initialize("SphereSize", "Sphere Size", "Radius of Eraser Sphere", sphereRadius, DoubleRange(0,200,1), 0, QDomNode());
	connect(mSphereSizeAdapter.get(), &DoubleProperty::changed, this, &EraserWidget::sphereSizeChangedSlot);
	mSphereSize = new SpinBoxAndSliderGroupWidget(this, mSphereSizeAdapter);
	layout->addWidget(mSphereSize);

	ImagePtr image = mPatientModelService->getActiveImage();
	int eraseValue = 0;
	if(image)
		eraseValue = image->getMin();
	mEraseValueAdapter = DoubleProperty::initialize("EraseValue", "Erase value", "Erase/draw with value", eraseValue, DoubleRange(1,200,1), 0, QDomNode());

	mActiveImageProxy = ActiveImageProxy::New(mPatientModelService);
	connect(mActiveImageProxy.get(), &ActiveImageProxy::activeImageChanged, this, &EraserWidget::activeImageChangedSlot);

	mEraseValueWidget = new SpinBoxAndSliderGroupWidget(this, mEraseValueAdapter);
	layout->addWidget(mEraseValueWidget);

	layout->addStretch();

	this->enableButtons();
}
Exemplo n.º 18
0
DoublePropertyPtr SmoothingImageFilter::getSigma(QDomElement root)
{
	return DoubleProperty::initialize("Smoothing sigma", "",
	                                             "Used for smoothing the segmented volume. Measured in units of image spacing.",
	                                             0.10, DoubleRange(0, 5, 0.01), 2, root);
}
Exemplo n.º 19
0
void PerformanceTab::init()
{
  int renderingInterval = settings()->value("renderingInterval").toInt();

  QLabel* renderingIntervalLabel = new QLabel(tr("Rendering interval"));

  mRenderingIntervalSpinBox = new QSpinBox;
  mRenderingIntervalSpinBox->setSuffix("ms");
  mRenderingIntervalSpinBox->setMinimum(4);
  mRenderingIntervalSpinBox->setMaximum(1000);
  mRenderingIntervalSpinBox->setValue(renderingInterval);
  connect(mRenderingIntervalSpinBox, SIGNAL(valueChanged(int)), this, SLOT(renderingIntervalSlot(int)));

  mRenderingRateLabel = new QLabel("");
  this->renderingIntervalSlot(renderingInterval);

  double Mb = pow(10.0,6);
  bool ok = true;
  double maxRenderSize = settings()->value("View3D/maxRenderSize").toDouble(&ok);
  if (!ok)
    maxRenderSize = 10 * Mb;
  mMaxRenderSize = DoubleProperty::initialize("MaxRenderSize", "Max Render Size (Mb)", "Maximum size of volumes used in volume rendering. Applies to new volumes.", maxRenderSize, DoubleRange(1*Mb,300*Mb,1*Mb), 0, QDomNode());
  mMaxRenderSize->setInternal2Display(1.0/Mb);

  double stillUpdateRate = settings()->value("stillUpdateRate").value<double>();
	mStillUpdateRate = DoubleProperty::initialize("StillUpdateRate", "Still Update Rate",
																											"<p>Still Update Rate in vtkRenderWindow. "
																											"Increasing the value may improve rendering speed "
																											"at the cost of render quality.</p> "
																											"Generally raycast rendering requires this to be low (0.001), "
																											"while texture based rendering requires it to be high (5-10)."
																											"<p>Restart needed.</p>",
																											stillUpdateRate, DoubleRange(0.0001, 20, 0.0001), 4, QDomNode());

  mSmartRenderCheckBox = new QCheckBox("Smart Render");
  mSmartRenderCheckBox->setChecked(settings()->value("smartRender", true).toBool());
  mSmartRenderCheckBox->setToolTip("Render only when scene has changed, plus once per second.");

  m3DVisualizer = StringProperty::initialize("ImageRender3DVisualizer",
	  "3D Renderer",
	  "Select 3D visualization method for images",
	  settings()->value("View3D/ImageRender3DVisualizer").toString(),
	  this->getAvailableVisualizers(),
	  QDomNode());
  m3DVisualizer->setDisplayNames(this->getAvailableVisualizerDisplayNames());

	bool useGPU2DRender = settings()->value("View2D/useGPU2DRendering").toBool();
  mGPU2DRenderCheckBox = new QCheckBox("2D Overlay");
  mGPU2DRenderCheckBox->setChecked(useGPU2DRender);
  mGPU2DRenderCheckBox->setToolTip("<p>Use a GPU-based 2D renderer instead of "
								   "the software-based one, if available.</p>"
								   "<p>This enables multiple volume rendering in 2D.<p>");

	bool linearInterpolationIn2D = settings()->value("View2D/useLinearInterpolationIn2DRendering").toBool();
	mLinearInterpolationIn2DCheckBox = new QCheckBox("Linear interpolation in 2D (Requires restart)");
	mLinearInterpolationIn2DCheckBox->setChecked(linearInterpolationIn2D);
	mLinearInterpolationIn2DCheckBox->setToolTip("<p>Use linear interpolation in GPU 2D rendering "
									 "instead of nearest.</p>"
										"<p>Requires restart.<p>");

  bool optimizedViews = settings()->value("optimizedViews").toBool();
  mOptimizedViewsCheckBox = new QCheckBox("Optimized Views");
  mOptimizedViewsCheckBox->setChecked(optimizedViews);
  mOptimizedViewsCheckBox->setToolTip("<p>Merge all non-3D views into a single vtkRenderWindow</p>"
									  "<p>This speeds up render on some platforms, still experimental.<p>");

  bool useGPU3DDepthPeeling = settings()->value("View3D/depthPeeling").toBool();
  mGPU3DDepthPeelingCheckBox = new QCheckBox("Use GPU 3D depth peeling");
  mGPU3DDepthPeelingCheckBox->setChecked(useGPU3DDepthPeeling);
  mGPU3DDepthPeelingCheckBox->setToolTip("Use a GPU-based 3D depth peeling to correctly visualize translucent surfaces.");

  //Layout
  mMainLayout = new QGridLayout;
  mMainLayout->addWidget(renderingIntervalLabel, 0, 0);
  new SpinBoxGroupWidget(this, mMaxRenderSize, mMainLayout, 1);
  mMainLayout->addWidget(mRenderingIntervalSpinBox, 0, 1);
  mMainLayout->addWidget(mRenderingRateLabel, 0, 2);
	mMainLayout->addWidget(mSmartRenderCheckBox, 2, 0);
	mMainLayout->addWidget(mGPU2DRenderCheckBox, 5, 0);
	mMainLayout->addWidget(mLinearInterpolationIn2DCheckBox, 6, 0);
	mMainLayout->addWidget(mOptimizedViewsCheckBox, 7, 0);
	mMainLayout->addWidget(mGPU3DDepthPeelingCheckBox, 8, 0);
	new SpinBoxGroupWidget(this, mStillUpdateRate, mMainLayout, 9);
	mMainLayout->addWidget(sscCreateDataWidget(this, m3DVisualizer), 10, 0, 1, 2);

  mMainLayout->setColumnStretch(0, 2);
  mMainLayout->setColumnStretch(1, 2);
  mMainLayout->setColumnStretch(2, 1);

  mTopLayout->addLayout(mMainLayout);
}
Exemplo n.º 20
0
void MeshPropertyData::initialize()
{
	//-------------------------------------------------------------------------
	mColor = ColorProperty::initialize("Color", "",
									   "Mesh color",
									   QColor("red"));
	this->addProperty(mColor);

	//-------------------------------------------------------------------------
	mUseColorFromPolydataScalars = BoolProperty::initialize( "colorFromPolydataScalars", "Color from polydata scalars",
									   "If your polydata has a scalar array with color data in you can use that to color the mesh.",
									   false);
	this->addProperty(mUseColorFromPolydataScalars);
	//-------------------------------------------------------------------------
	mVisSize = DoubleProperty::initialize("visSize", "Point size",
										  "Visualized size of points, glyphs etc.",
										  2, DoubleRange(1, 20, 1), 0);
	mVisSize->setGuiRepresentation(DoublePropertyBase::grSLIDER);
	this->addProperty(mVisSize);
	//-------------------------------------------------------------------------
	mBackfaceCulling = BoolProperty::initialize("backfaceCulling", "Backface culling",
									   "Set backface culling on. This makes transparent meshes work, "
									   "but only draws outside mesh walls "
									   "(eg. navigating inside meshes will not work).",
									   false);
	this->addProperty(mBackfaceCulling);
	//-------------------------------------------------------------------------
	mFrontfaceCulling = BoolProperty::initialize("frontfaceCulling", "Frontface culling",
									   "Set frontface culling on. Can be used to make transparent "
									   "meshes work from inside the meshes.",
									   false);
	this->addProperty(mFrontfaceCulling);
	//-------------------------------------------------------------------------
	mRepresentation = StringProperty::initialize("representation", "Representation",
												 "How to represent model visually",
												 QString::number(VTK_SURFACE),
												 QStringList()
												 << QString::number(VTK_SURFACE)
												 << QString::number(VTK_WIREFRAME)
												 << QString::number(VTK_POINTS));
	std::map<QString,QString> representationNames;
	representationNames[QString::number(VTK_SURFACE)] = "Surface";
	representationNames[QString::number(VTK_WIREFRAME)] = "Wireframe";
	representationNames[QString::number(VTK_POINTS)] = "Points";
	mRepresentation->setDisplayNames(representationNames);
	this->addProperty(mRepresentation);
	//-------------------------------------------------------------------------
	mEdgeVisibility = BoolProperty::initialize("edgeVisibility", "Show Edges",
														"Show model edges",
														false);
	this->addProperty(mEdgeVisibility);
	//-------------------------------------------------------------------------
	mEdgeColor = ColorProperty::initialize("edgeColor", "Edge color",
										   "Edge color, used when edges are visible.",
										   QColor("green"));
	this->addProperty(mEdgeColor);
	//-------------------------------------------------------------------------
	mAmbient = DoubleProperty::initialize("ambient", "Ambient",
										  "Ambient color coefficient",
										  0.2, DoubleRange(0, 1, 0.05), 2);
	mAmbient->setGuiRepresentation(DoublePropertyBase::grSLIDER);
	this->addProperty(mAmbient);
	//-------------------------------------------------------------------------
	mDiffuse = DoubleProperty::initialize("diffuse", "Diffuse",
										  "Diffuse color coefficient",
										  0.9, DoubleRange(0, 1, 0.05), 2);
	mDiffuse->setGuiRepresentation(DoublePropertyBase::grSLIDER);
	this->addProperty(mDiffuse);
	//-------------------------------------------------------------------------
	mSpecular = DoubleProperty::initialize("specular", "Specular",
										  "Specular color coefficient",
										  0.3, DoubleRange(0, 1, 0.05), 2);
	mSpecular->setGuiRepresentation(DoublePropertyBase::grSLIDER);
	this->addProperty(mSpecular);
	//-------------------------------------------------------------------------
	mSpecularPower = DoubleProperty::initialize("specularPower", "Specular Power",
										  "Specular color power",
										  15, DoubleRange(1, 30, 1), 0);
	mSpecularPower->setGuiRepresentation(DoublePropertyBase::grSLIDER);
	this->addProperty(mSpecularPower);
	//-------------------------------------------------------------------------
}