example_HandleWidget
example_SeedWidget
example_SphereWidget
- ##example_Test_Memento
+ example_Test_Memento
##example_MarchingCubes
##example_OtsuFilter
##example_RGBImageToHSVChannels
// -------------------------------------------------------------------------
-std::string _path = "C://dev//creatis//cpPlugins//build//Debug//cpPluginsIO.dll";
+std::string _pathIOplugin = "C://dev//creatis//cpPlugins//build//Debug//cpPluginsIO.dll";
std::string _img = "C://img//SphereVolume.mhd";
int main(int argc, char* argv[])
{
if (argc >= 3)
{
- _path = argv[1];
+ _pathIOplugin = argv[1];
_img = argv[2];
}
// Create interface
TInterface plugins;
- if (!plugins.Load(_path))
+ if (!plugins.Load(_pathIOplugin))
{
std::cerr << "Failed to load plugins." << std::endl;
return(1);
vtkSmartPointer<TSphereWidget> sphereWidget =
vtkSmartPointer<TSphereWidget>::New();
sphereWidget->SetInteractor(interactor);
- sphereWidget->CreateDefaultRepresentation();
+// sphereWidget->CreateDefaultRepresentation();
- vtkSphereRepresentation* sphereRepresentation =
+ /* vtkSphereRepresentation* sphereRepresentation =
vtkSphereRepresentation::SafeDownCast(sphereWidget->GetRepresentation());
- sphereRepresentation->HandleVisibilityOn();
+ sphereRepresentation->HandleVisibilityOn();*/
// Begin interaction
renderer->ResetCamera();
#include <future>
#include <iostream>
#include <cpExtensions/IO/MementoState.h>
+#include <cpPlugins/Plugins/BasicFilters/BinaryErodeImageFilter.h>
-#include <vtkSmartPointer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
-#include <vtkImageCast.h>
-#include <vtkMetaImageWriter.h>
-#include <vtkMetaImageReader.h>
-#include <vtkImageMandelbrotSource.h>
-#include <vtkImageActor.h>
-#include <vtkRenderWindowInteractor.h>
-
-#include <itkImage.h>
-#include <itkBinaryErodeImageFilter.h>
-#include <itkBinaryBallStructuringElement.h>
-#include <itkImageFileReader.h>
-
#include <itkImageToVTKImageFilter.h>
-#include <itkVTKImageToImageFilter.h>
-#include <itkBinaryThresholdImageFilter.h>
-#include <itkInvertIntensityImageFilter.h>
-
-typedef itk::Image<unsigned char, 2> ImageType;
-typedef itk::ImageFileReader<ImageType> ReaderType;
-typedef cpPlugins::Interface::Image TPluginImage;
+#ifdef WIN32
+#define myWait Sleep(10000);
+#else
+#define myWait usleep(10000);
+#endif
+
+
+// -------------------------------------------------------------------------
+// type definiftions
+
+typedef cpPlugins::Interface::Interface TInterface;
+typedef cpPlugins::Interface::ProcessObject TProcessObject;
+typedef cpPlugins::Interface::DataObject TDataObject;
+typedef cpPlugins::Interface::Image TImage;
+typedef cpPlugins::Interface::Parameters TParameters;
+typedef TInterface::TClasses TClasses;
+
+typedef cpExtensions::Visualization::ImageSliceActors TSliceActors;
+
+typedef cpExtensions::IO::MementoState TMemento;
+typedef cpPlugins::BasicFilters::BinaryErodeImageFilter TBinaryErodeFilter;
+// -------------------------------------------------------------------------
+
+std::string _pathIOplugin = "C://dev//creatis//cpPlugins//build//Debug//cpPluginsIO.dll";
+std::string _pathBasicFiltersPlugin= "C://dev//creatis//cpPlugins//build//Debug//cpPluginsBasicFilters.dll";
+std::string _img = "C://img//SphereVolume.mhd";
+
+int main(int argc, char* argv[])
+{
+ if (argc >= 3)
+ {
+ _img = argv[1];
+ _pathIOplugin = argv[2];
+ _pathBasicFiltersPlugin = argv[3];
+ }
+
+ // Create interface
+ TInterface plugins;
+ if (!plugins.Load(_pathIOplugin) ||
+ !plugins.Load(_pathBasicFiltersPlugin))
+ {
+ std::cerr << "Failed to load plugins." << std::endl;
+ return(1);
+ }
+
+ // Create reader
+ TProcessObject::Pointer reader;
+ reader = plugins.CreateProcessObject("cpPlugins::IO::ImageReader");
+ if (reader.IsNull())
+ {
+ std::cerr
+ << "No suitable reader found in plugins." << std::endl
+ << "Reader: " << reader.GetPointer() << std::endl
+ << std::endl;
+ return(1);
+ }
+
+ // Configure reader
+ TParameters* reader_params = reader->GetParameters();
+ reader_params->AddToStringList("FileNames", _img);
+
+ // Execute pipeline
+ std::string err = reader->Update();
+ if (err != "")
+ {
+ std::cerr << "ERROR: " << err << std::endl;
+ return(1);
+
+ }
+
+ TImage* image = reader->GetOutput< TImage >("Output");
-int main() {
- auto memento = cpExtensions::IO::MementoState();
-
- //here goes the code
-
-
- std::string filePath = "julia_mha.mhd";
- std::string filePathRaw = "julia_mha.raw";
- // Create an image
- vtkSmartPointer<vtkImageMandelbrotSource> source =
- vtkSmartPointer<vtkImageMandelbrotSource>::New();
-
- vtkSmartPointer<vtkImageCast> castFilter =
- vtkSmartPointer<vtkImageCast>::New();
- castFilter->SetOutputScalarTypeToUnsignedChar();
- castFilter->SetInputConnection(source->GetOutputPort());
- castFilter->Update();
-
- vtkSmartPointer<vtkMetaImageWriter> writer =
- vtkSmartPointer<vtkMetaImageWriter>::New();
- writer->SetInputConnection(castFilter->GetOutputPort());
- writer->SetFileName(filePath.c_str());
- writer->SetRAWFileName(filePathRaw.c_str());
- writer->Write();
-
- //ReaderType::Pointer reader = ReaderType::New();
- vtkSmartPointer<vtkMetaImageReader> reader =
- vtkSmartPointer<vtkMetaImageReader>::New();
- reader->SetFileName(filePath.c_str());
- reader->Update();
-
//first memento
- /* auto obj = TPluginImage::New();
-
- auto oo = dynamic_cast<cpPlugins::Interface::Image *> (reader->GetOutput());
- obj->SetSource(oo);
- memento.SetToMemento(oo);*/
-
+ TMemento* _memento = new TMemento();
+ _memento->SetToMemento(image);
+
+ /* auto retrievedImage = _memento->GetFromMemento(1);
+ image->SetVTK(retrievedImage);
+*/
// filter 1 (state 2) ---------------------------------------------------------------
+
+ TProcessObject::Pointer binaryFilter;
+ binaryFilter = plugins.CreateProcessObject("cpPlugins::BasicFilters::BinaryErodeImageFilter");
+ if (binaryFilter.IsNull())
+ {
+ std::cerr
+ << "No suitable reader found in plugins." << std::endl
+ << "Reader: " << binaryFilter.GetPointer() << std::endl
+ << std::endl;
+ return(1);
+ }
+
+ // filter 1
+ TDataObject * readerOut = reader->GetOutput< TDataObject >("Output");
+ binaryFilter->SetInput("Input", readerOut);
+ binaryFilter->Update();
+ _memento->SetToMemento(binaryFilter->GetOutput< TImage >("Output"));
+
+ myWait;
+
+ vtkSmartPointer<vtkImageData> retrievedImage = _memento->MementoUndo();
- typedef itk::BinaryBallStructuringElement<
- ImageType::PixelType, 2> StructuringElementType;
- StructuringElementType structuringElement;
- structuringElement.SetRadius(10);
- structuringElement.CreateStructuringElement();
-
- typedef itk::VTKImageToImageFilter<ImageType> imgToFilter;
- imgToFilter::Pointer connectorimg = imgToFilter::New();
- connectorimg->SetInput(reader->GetOutput());
- connectorimg->Update();
-
- typedef itk::BinaryErodeImageFilter<ImageType, ImageType, StructuringElementType>
- BinaryErodeImageFilterType;
+ // the retrieved image could not be ready if this happens the function returns null
+ // for the test we made the example wait before try to read but this is the way
+ // to handle this
+ if (retrievedImage == nullptr)
+ {
+ return (1);
+ }
- BinaryErodeImageFilterType::Pointer erodeFilter
- = BinaryErodeImageFilterType::New();
- erodeFilter->SetInput(connectorimg->GetOutput());
- erodeFilter->SetKernel(structuringElement);
-
- // filter 2 (state 3) ---------------------------------------------------------------
-
- typedef itk::BinaryThresholdImageFilter<ImageType, ImageType>
- BinaryThresholdImageFilterType;
-
- BinaryThresholdImageFilterType::Pointer thresholdFilter
- = BinaryThresholdImageFilterType::New();
- thresholdFilter->SetInput(erodeFilter->GetOutput());
- thresholdFilter->SetLowerThreshold(10);
- thresholdFilter->SetUpperThreshold(30);
- thresholdFilter->SetInsideValue(255);
- thresholdFilter->SetOutsideValue(0);
-
-
- // filter 3 (state 4) ---------------------------------------------------------------
-
- typedef itk::InvertIntensityImageFilter <ImageType>
- InvertIntensityImageFilterType;
-
- InvertIntensityImageFilterType::Pointer invertIntensityFilter
- = InvertIntensityImageFilterType::New();
- invertIntensityFilter->SetInput(thresholdFilter->GetOutput());
- invertIntensityFilter->SetMaximum(255);
-
- // undo (state 3) ---------------------------------------------------------------
-
- // undo (state 2) ---------------------------------------------------------------
-
- // redo (state 3) ---------------------------------------------------------------
-
- // visualization -- just for test
-
- typedef itk::ImageToVTKImageFilter<ImageType> ConnectorType;
- ConnectorType::Pointer connector = ConnectorType::New();
- connector->SetInput(invertIntensityFilter->GetOutput());
- connector->Update();
-
- vtkSmartPointer<vtkImageActor> actor =
- vtkSmartPointer<vtkImageActor>::New();
- actor->GetMapper()->SetInputData(connector->GetOutput());
-
- vtkSmartPointer<vtkRenderer> renderer =
- vtkSmartPointer<vtkRenderer>::New();
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
- renderWindow->AddRenderer(renderer);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- renderWindowInteractor->SetRenderWindow(renderWindow);
-
- renderer->AddActor(actor);
- renderer->SetBackground(.2, .3, .4);
-
- renderWindow->Render();
- renderWindowInteractor->Start();
-
-
-
-//#ifdef _DEBUG
-// auto i = 0;
-// std::cout << "wait for close";
-// std::cin >> i;
-//#endif
+ //image->SetVTK(retrievedImage.Get()); // this metohd is not implemented yet
+
+ // Configure visualization objects
+ vtkSmartPointer< vtkRenderer > renderer =
+ vtkSmartPointer< vtkRenderer >::New();
+ renderer->SetBackground(0.1, 0.1, 0.1);
+
+ vtkSmartPointer< vtkRenderWindow > window =
+ vtkSmartPointer< vtkRenderWindow >::New();
+ window->AddRenderer(renderer);
+ window->SetSize(600, 600);
+
+ // Set up the interaction
+ vtkSmartPointer< vtkRenderWindowInteractor > interactor =
+ vtkSmartPointer< vtkRenderWindowInteractor >::New();
+ window->SetInteractor(interactor);
+
+ // Create slice actors
+ vtkSmartPointer< TSliceActors > image_actors =
+ vtkSmartPointer< TSliceActors >::New();
+ //image_actors->AddInputData(image->GetVTK< vtkImageData >(), 2);
+ image_actors->AddInputData(retrievedImage, 2);
+ image_actors->PushActorsInto(window);
+
+ // Begin interaction
+ renderer->ResetCamera();
+ window->Render();
+ interactor->Start();
return 0;
#include <vtkMetaImageReader.h>
#include <vtkMetaImageWriter.h>
+#include <future>
+
+
+
// -------------------------------------------------------------------------
cpExtensions::IO::MementoState::MementoState()
{
- m_Id = 0;
+ m_maxId = m_Id = 0;
+ m_stateIt = m_stateReady.begin();
};
// -------------------------------------------------------------------------
-//cpExtensions::IO::MementoState::MementoState(long id, TPluginImage* _img)
-//{
-// SetToMemento(_img);
-//}
-//
-//bool
-//cpExtensions::IO::MementoState::SetToMemento(TPluginObject * _do)
-//{
-// char base[] = "state";
-// std::ostringstream oss;
-// this->m_Id++;
-// oss << this->m_Id;
-// std::string str = oss.str();
-// auto complement = str.c_str();
-//
-// std::string fileName(base);
-// fileName.append(complement);
-// fileName.append(".mhd");
-//
-// std::string fileNameRaw(base);
-// fileNameRaw.append(complement);
-// fileNameRaw.append(".raw");
-//// save(fileName, fileNameRaw, _img);
-//
-//
-// vtkSmartPointer<vtkMetaImageWriter> writer =
-// vtkSmartPointer<vtkMetaImageWriter>::New();
-//
-// auto img = TPluginImage::New();
-// img->SetSource(_do);
-//
-// // writer->SetInputData(_do->GetVTK<vtkDataObject>());
-// writer->SetInputData(img->GetVTK<vtkDataObject>());
-//
-// writer->SetFileName(fileName.c_str());
-// writer->SetRAWFileName(fileNameRaw.c_str());
-// writer->Write();
-//
-// return true;
-//}
-//
-//
bool
cpExtensions::IO::MementoState::SetToMemento(cpPlugins::Interface::Image* _img)
{
char base[] = "state";
std::ostringstream oss;
- this->m_Id++;
+ this->m_Id;
oss << this->m_Id;
std::string str = oss.str();
auto complement = str.c_str();
std::string fileNameRaw(base);
fileNameRaw.append(complement);
fileNameRaw.append(".raw");
- save(fileName, fileNameRaw, _img);
+ //save(fileName, fileNameRaw, _img);
+ m_stateReady.insert(m_stateReady.begin() + m_Id, false);
+ std::async(std::launch::async, &MementoState::Save, this, fileName, fileNameRaw, _img);
+
+ m_stateReady[m_Id] = true;
+ m_Id++;
+
+ if (m_Id > m_maxId)
+ {
+ m_maxId = m_Id;
+ }
return true;
}
-//
-//
-//// -------------------------------------------------------------------------
-//vtkSmartPointer<vtkMetaImageReader>
-//cpExtensions::IO::MementoState::getMemento(long id)
-//{
-// char base[] = "state";
-// std::ostringstream oss;
-// oss << id;
-// std::string str = oss.str();
-// auto complement = str.c_str();
-//
-// std::string fileName(base);
-// fileName.append(complement);
-// fileName.append(".mhd");
-// return load(fileName);
-//}
-//
+
+
+// -------------------------------------------------------------------------
+vtkSmartPointer<vtkImageData>
+cpExtensions::IO::MementoState::GetFromMemento(long id)
+{
+ if (id > m_maxId)
+ {
+ return nullptr;
+ }
+
+ char base[] = "state";
+ std::ostringstream oss;
+ oss << id;
+ std::string str = oss.str();
+ auto complement = str.c_str();
+
+ std::string fileName(base);
+ fileName.append(complement);
+ fileName.append(".mhd");
+ return Load(fileName);
+ /*std::future<vtkSmartPointer<vtkImageData>> result(std::async(std::launch::async, &MementoState::Load, this, fileName));
+ return result.get();*/
+}
+
// -------------------------------------------------------------------------
-void
+vtkSmartPointer<vtkImageData>
+cpExtensions::IO::MementoState::MementoUndo()
+{
+ char base[] = "state";
+ std::ostringstream oss;
+ oss << --this->m_Id;
+ std::string str = oss.str();
+ auto complement = str.c_str();
+
+ std::string fileName(base);
+ fileName.append(complement);
+ fileName.append(".mhd");
+
+ if (m_stateReady.at(this->m_Id))
+ {
+ return Load(fileName);
+ }
+
+ return nullptr;
+}
+
+
+vtkSmartPointer<vtkImageData>
+cpExtensions::IO::MementoState::MementoRedo()
+{
+ char base[] = "state";
+ std::ostringstream oss;
+ oss << ++this->m_Id;
+ std::string str = oss.str();
+ auto complement = str.c_str();
+
+ std::string fileName(base);
+ fileName.append(complement);
+ fileName.append(".mhd");
+
+ if (m_stateReady.at(this->m_Id) &&
+ this->m_Id <= this->m_maxId)
+ {
+ return Load(fileName);
+ }
+ return nullptr;
+}
+
+// -------------------------------------------------------------------------
+void
cpExtensions::IO::MementoState::
-save(const std::string& filename, const std::string& filenameRaw, cpPlugins::Interface::Image* img) {
-
- vtkSmartPointer<vtkMetaImageWriter> writer =
- vtkSmartPointer<vtkMetaImageWriter>::New();
- writer->SetInputData(img->GetVTK< vtkImageData >());
- writer->SetFileName(filename.c_str());
- writer->SetRAWFileName(filenameRaw.c_str());
- writer->Write();
-
+Save(const std::string& filename, const std::string& filenameRaw, cpPlugins::Interface::Image* img) {
+
+ vtkSmartPointer<vtkMetaImageWriter> writer =
+ vtkSmartPointer<vtkMetaImageWriter>::New();
+ writer->SetInputData(img->GetVTK< vtkImageData >());
+ writer->SetFileName(filename.c_str());
+ writer->SetRAWFileName(filenameRaw.c_str());
+ writer->Write();
}
// -------------------------------------------------------------------------
-vtkSmartPointer<vtkMetaImageReader>
-cpExtensions::IO::MementoState::load(const std::string& filename) {
-
- vtkSmartPointer<vtkMetaImageReader> reader =
- vtkSmartPointer<vtkMetaImageReader>::New();
- reader->SetFileName(filename.c_str());
- reader->Update();
- return reader;
-
-//return( NULL );
+vtkSmartPointer<vtkImageData>
+cpExtensions::IO::MementoState::Load(const std::string& filename) {
+
+ vtkSmartPointer<vtkMetaImageReader> reader =
+ vtkSmartPointer<vtkMetaImageReader>::New();
+ reader->SetFileName(filename.c_str());
+
+ reader->Update();
+ return reader->GetOutput();
+
}
// eof - $RCSfile$
#include <cpPlugins/Interface/Mesh.h>
#include <vtkMetaImageReader.h>
-
-// -------------------------------------------------------------------------
-
-
+#include <vtkCommand.h>
namespace cpExtensions
{
namespace IO
{
- //==========================================================================
-// Plugins types
-//typedef cpPlugins::Interface::Interface TPluginsInterface;
-//typedef cpPlugins::Interface::Object TPluginObject;
-//typedef cpPlugins::Interface::DataObject TPluginData;
-//typedef cpPlugins::Interface::Image TPluginImage;
-//typedef cpPlugins::Interface::ImplicitFunction TPluginImplicitFunction;
-//typedef cpPlugins::Interface::Mesh TPluginMesh;
-//typedef cpPlugins::Interface::ProcessObject TPluginFilter;
-//typedef cpPlugins::Interface::Parameters TParameters;
-//
-//typedef cpExtensions::Visualization::MPRObjects TMPRObjects;
-
class cpExtensions_EXPORT MementoState
{
private:
long m_Id;
-
+ long m_maxId;
+ std::vector<bool> m_stateReady;
+ std::vector<bool>::iterator m_stateIt;
public:
MementoState();
-// MementoState(long id, cpPlugins::Interface::Image * _img);
-
bool SetToMemento(cpPlugins::Interface::Image* _img);
-// bool SetToMemento(itk::ProcessObject po);
-
-// vtkSmartPointer<vtkMetaImageReader> getMemento(long id);
+ vtkSmartPointer<vtkImageData> MementoUndo();
+ vtkSmartPointer<vtkImageData> MementoRedo();
+ vtkSmartPointer<vtkImageData> GetFromMemento(long id);
private:
- void save(const std::string& filename, const std::string& filenameRaw, cpPlugins::Interface::Image* img);
- vtkSmartPointer<vtkMetaImageReader> load(const std::string& filename);
+ void Save(const std::string& filename, const std::string& filenameRaw, cpPlugins::Interface::Image* img);
+ vtkSmartPointer<vtkImageData> Load(const std::string& filename);
};
}
#include <vtkWidgetRepresentation.h>
#include <vtkActor.h>
#include <vtkSphereRepresentation.h>
-#include <vtkSphereWidget2.h>
#include <vtkSmartPointer.h>
-
+#include <vtkSphere.h>
// -------------------------------------------------------------------------
cpExtensions::Interaction::SphereWidget::
SphereWidget()
: Superclass()
{
- vtkSmartPointer<vtkSphereRepresentation> sphereRepresentation =
- vtkSphereRepresentation::SafeDownCast(this->GetRepresentation());
+ /*vtkSmartPointer<vtkself> self =
+ vtkself::SafeDownCast(this->GetRepresentation());*/
- //sphereRepresentation->SetHandleSize(0);
- sphereRepresentation->SetRadialLine(2);
- sphereRepresentation->SetRadius(7);
+ //self->SetHandleSize(0);
+ //self->SetRadialLine(2);
+ this->SetRadius(7);
- sphereRepresentation->SetPhiResolution(10);
- sphereRepresentation->SetThetaResolution(20);
+ this->SetPhiResolution(10);
+ this->SetThetaResolution(20);
- //sphereRepresentation->HandleVisibilityOff();
- //sphereRepresentation->SetHandleText(0);
- sphereRepresentation->SetRepresentationToWireframe();
+ //self->HandleVisibilityOff();
+ //self->SetHandleText(0);
+ this->SetRepresentationToWireframe();
// Remove default translations
/* vtkWidgetEventTranslator* t = this->GetEventTranslator();
SphereWidget* self = reinterpret_cast<SphereWidget*>(data);
double handlePosition[3];
- vtkSphereRepresentation* sphereRepresentation =
- vtkSphereRepresentation::SafeDownCast(self->GetRepresentation());
-
-
+ /* vtkself* self =
+ vtkself::SafeDownCast(self->GetRepresentation());
+ */
+ auto center = self->GetCenter();
+ auto center2 = self->GetCenter();
+ auto radius = self->GetRadius();
- auto center = sphereRepresentation->GetCenter();
self->Superclass::StartInteraction();
switch (key)
{
case 122: // Z & z
case 90:
- sphereRepresentation->SetRadius(sphereRepresentation->GetRadius() + 0.1);
+ radius += 0.1;
+ //self->SetRadius(radius);
break;
case 88: // X & x
case 120:
- sphereRepresentation->SetRadius(sphereRepresentation->GetRadius() - 0.1);
+ radius -= 0.1;
+ //self->SetRadius(radius);
break;
case 119: // W & w
case 87:
center[0] += 1;
- sphereRepresentation->SetCenter(center);
+ self->Translate(center, center2);
break;
case 83: // S & s
case 115:
center[0] -= 1;
- sphereRepresentation->SetCenter(center);
+ self->Translate(center, center2);
break;
case 65: // A & a
case 97:
center[1] += 1;
- sphereRepresentation->SetCenter(center);
+ self->SetCenter(center);
break;
case 100: // D & d
case 68:
center[1] -= 1;
- sphereRepresentation->SetCenter(center);
+ self->SetCenter(center);
break;
case 81: // Q & q
case 113:
center[2] += 1;
- sphereRepresentation->SetCenter(center);
+ self->SetCenter(center);
break;
case 69: // E & e
case 101:
center[2] -= 1;
- sphereRepresentation->SetCenter(center);
+ self->SetCenter(center);
break;
default:
break;
}
- self->SetKeyPressActivation(1);
- self->Render();
+
+ self->SetRadius(radius);
+ self->Translate(center, center2);
+
+ vtkSmartPointer<vtkSphere> sphere = vtkSmartPointer<vtkSphere>::New();
+
+
+ self->InvokeEvent(vtkCommand::ModifiedEvent, NULL);
+ self->Modified();
+ self->GetInteractor()->Render();
+ self->ReleaseFocus();
}
#include <cpExtensions/cpExtensions_Export.h>
#include <cpExtensions/Interaction/BaseInteractorStyle.h>
-#include <vtkSphereWidget2.h>
+#include <vtkSphereWidget.h>
namespace cpExtensions
{
/**
*/
class cpExtensions_EXPORT SphereWidget
- : public vtkSphereWidget2
+ : public vtkSphereWidget
{
public:
typedef SphereWidget Self;
- vtkTypeMacro( SphereWidget, vtkSphereWidget2 );
+ vtkTypeMacro( SphereWidget, vtkSphereWidget );
typedef cpExtensions::Interaction::BaseInteractorStyle TBaseStyle;
typedef TBaseStyle::TMouseCommand TMouseCommand;
const double& r, const double& g, const double& b
)
{
+ return false;
}
// -------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / cpPlugins.git / commitdiff