General on UserVoice

Do you think about launching a C# wrapper? [is now completed]

2011-11-11T11:34:18-08:00

I hold a chair for bioinformatics at the university of applied sciences in Emden. The vtk may be useful. Just two things prevent it to be: 1. The quite bad documentation/examples for beginners and 2. The miss of a good working c# wrapper

Do you think about launching a C# wrapper? [updated]

2011-11-11T11:34:18-08:00

berk.geveci (admin) responded:

- Activiz .NET provide C# wrappers for VTK

- There are 2 books documenting VTK in detail

Do you think about launching a C# wrapper? [updated]

2011-11-11T10:37:10-08:00

David Cole said:

Have you tried using ActiViz .NET? It's sole purpose is to be C# wrappers for VTK...

http://www.kitware.com/products/activiz.html
http://www.kitware.com/products/avdownload.php

It is free and open source since January, 2011.

Better documentation [updated]

2011-10-28T06:49:09-07:00

Make a pass through VTK classes to ensure all methods and arguments are clearly documented.

Vizcat said:

Heck, "better" isn't even necessary, crappy, but correct would be adequate. When the docs make multiple mutually disagreeing, statements regarding function parameter requirements, none of which are actually correct, and then point the reader to an example case at hasn't been valid for several releases, even /no/ documentation would be an improvement. At least then we wouldn't go down the garden path of thinking that it was possible to use, without more work than a complete rewrite.

Fix transparency

2011-10-28T06:44:09-07:00

CUDA VTK extension on python

2011-07-21T14:21:13-07:00

Alex Soloviev suggested:
I've found only TCL examples for VTK via Cuda. Can you give me advice how I can use VTK via nVidia CUDA with Python?

Implement OpenGIS Implementation Specification

2011-07-05T18:13:28-07:00

7islands suggested:
Implementation of the standardized basic API specification for GIS data handling, "OpenGIS Implementation Specification for Geographic information - Simple feature access" ( http://www.opengeospatial.org/standards/sfa ), would be a great feature to be added to VTK. It should be a killer feature for VTK to be applied to the geographic information area.

Sparsed dynamic memory array

2011-05-10T23:58:10-07:00

Raul suggested:
Trying to make a real application with vtk that works under windows is nearly imposibble. The problem is that memory allocated by vtk must be consecutive, so it doesn't benefit for virtual memory (swap file memory). I suggest to create a new class vtkMemory that handle about this. This class stores memory and handle it as it where all consecutive memory, but internally it can be splitted into chunks to allow application to fit into system memory.

vtkplanecutter

2011-05-04T11:19:09-07:00

vtk with webgl [updated]

2010-12-26T22:04:41-08:00

What about to make a web version of vtk with webgl?

Alain said:

guys you can check out C++ Wt project they provided an example of how VTK and WebGL can be glued together. See the url: http://www.webtoolkit.eu/wt

vtk with webgl [updated]

2010-09-24T04:40:58-07:00

What about to make a web version of vtk with webgl?

mow reece said:

Same idea here (^_^) To my mind, this would involve a complete JavaScript recoding which means it'll spend a lot of time to recode all the stuff /(>_<)\ One other "idealistic" solution should be to guess to web browsers editors a sort of "libvtkweb" included support; but I don't think at all that they'll want.

vtk with webgl [updated]

2010-08-11T01:06:07-07:00

What about to make a web version of vtk with webgl?

sathish said:

Me too expecting vtk with webGL.

Move to a distributed version control system [is now completed]

2010-08-03T06:25:47-07:00

Use a distributed VCS like git, hg, bazaar.

Move to a distributed version control system [updated]

2010-08-02T19:36:57-07:00

Use a distributed VCS like git, hg, bazaar.

nairbv said:

I spent a while investigating distributed vcs's and they seem like a giant leap backwards to me. If you want a single file or directory out of the repository, you have to checkout the entire repo. Really impractical for most projects. Distributed VCS's have their place in large open source projects where individual contributors don't have commit privileges, but I see it as being inferior to cvs/svn/perforce in a business setting or for personal projects.

And yes, I would agree that it discourages frequent merges, which would be another detriment to distributed VCS's.

Even SVN with its "a branch/tag is a directory" architecture seemed like a step backwards from CVS's real braches/tags.

Add a cmake generator for IDE QT Creator [updated]

2010-08-02T05:40:11-07:00

As the current import function of QT Creator for cmake projects cannot handle only-header files properly, it would be helpful if a correct QT project file could be generated by cmake similar to Eclipse.

Jeff Baumes said:

I believe "Header-only" files are an issue for any CMake generator. Generally, only what is listed in the CMakeLists.txt files makes it into the GUI. This holds for Visual Studio. Qt Creator is better in that it seems to pick up associated headers that have the same name as implementation files in the CMakeLists.txt.

Add a cmake generator for IDE QT Creator

2010-08-02T01:42:56-07:00

Holger M suggested:
As the current import function of QT Creator for cmake projects cannot handle only-header files properly, it would be helpful if a correct QT project file could be generated by cmake similar to Eclipse.

add Scilab support

2010-06-24T00:56:56-07:00

yohplala suggested:
In the same way than matlab is supported, add support to Scilab through adequate classes: - vtkScilabEngineFilter - vtkScilabEngineInterface - vtkScilabMexAdapter Scilab (http://www.scilab.org/) is an open source program with a very active team. It would be very interesting to benefit both from Scilab and VTK processing functions. In the end, one may then think to have a Scilab plugin in ParaView to process dataset with Scilab functions, and benefit from ParaView workflow capabilities (filter pipeline) and ability to distribute computations (MPI) to leverage ParaView analysis capabilities.

Mac installation should be more user friendly

2010-06-18T10:03:22-07:00

I suggerst Test VTK with Sli .I didnot gain any performance with sli configaration.

2010-02-28T02:06:25-08:00

jalal.sadeghy suggested:
I have Tested a simple sphere with 0.5 mg polygon with SLI configuration but the performance hasn't chnaged .

vtk with webgl

2010-02-26T20:50:23-08:00

m.diegoli suggested:
What about to make a web version of vtk with webgl?

Declarative API [updated]

2010-02-01T11:00:59-08:00

Change most setters (and set macros) to return either "this" or an appropriate vtkObject pointer to allow more compact code such as sphere->SetRadius(10) ->SetThetaResolution(100) ->SetPhiResolution(100);

Jeff Baumes said:

It appears that this just isn't doable in C++. See Brad King's message.

http://markmail.org/message/uyuj4fe6wxfnaoqj

Declarative API [updated]

2010-02-01T07:45:59-08:00

berk.geveci said:

If I could, I vote against this as well.

Declarative API [updated]

2010-02-01T07:26:23-08:00

Kenneth Moreland said:

I am ambivalent to the functionality, but I think this would actually be a pain to implement. Sure, you could change the vtkSet* macros, but what of all the other Set methods that are not declared with macros in the header file? This is pervasive for vtkSetObjectMacro. This macro is rarely used in the header file because it requires the full class declaration (i.e. including the header file for the class), which is highly discouraged for any class but the parent class.

So this change would basically require every VTK class to be modified to adjust to the new return type all these Set methods. The only other option is to not require all the Set methods to return this, but then that puts an onus on the class user to look up which set methods return "this" and which do not. In the end, I think it would be too much of a pain to bother with.

add the documentation link to the resources web page as well as the help web page.

2009-12-29T07:43:08-08:00

wes.turner@kitware.com suggested:
Help is more for after you exhaust the standard mechanisms. Documentation is a standard and expected resource. We should keep it where it is, but should also add a link to the documentation under resources.

Add support for NetBeans IDE projects to CMake

2009-12-08T06:15:24-08:00

John Powell suggested:
I'd like to be able to build and debug VTK and projects using VTK (Java & C++) in the NetBeans IDE. There's a NetBeans IDE plugin that can interpret Ant projects, but that's an extra step I'd like to avoid.

Wrap enumerations [updated]

2009-12-08T06:06:17-08:00

Make enumeration values available from wrapped languages like Python.

John Powell said:

My vote is in hopes that this will be done for Java. I'd like to see constants like:
#define VTK_SCALE_BY_SCALAR 0
#define VTK_SCALE_BY_VECTOR 1
#define VTK_SCALE_BY_VECTORCOMPONENTS 2
#define VTK_DATA_SCALING_OFF 3
defined in vtkGlyph3D.h be available in some form in the Java wrapper.

Add a background box to vtkScalarBarActor like the box in the legend of XYPlots.

2009-12-08T05:55:05-08:00

John Powell suggested:
To make the vtkScalarBarActor more legible over complex scenery, it would help to have a background with programmable color/opacity like the Box object in the legend of the XYPlot actor. One implementation difficulty will be in creating a box that encompasses the labels & title which hang outside the area defined by the scalarbar actor's position, width & height. The scalar bar widget would need to be aware of this expanded size so that user's could resize the scalar bar by dragging its new edge.

Framework for sharing OpenGL resources between several vtkOpenGLRenderWindows

2009-12-01T07:41:00-08:00

Francois Bertel suggested:
See bug report 9983 for details. http://www.vtk.org/Bug/view.php?id=9983

Make underlying datatype of vtkPoints configurable via cmake (VTK_FLOAT => VTK_DOUBLE) [updated]

2009-11-23T00:50:15-08:00

When triangulating large volumes, the underlying data type float reaches quickly its limits. Rounding the data to float makes details disappear in case a triangle is far away from the origin of the coordinate system. In case float was choosen in the past for performance reasons, this shouldn't be a reason anymore with modern computers (of course the occupied memory will be twice as much).

Frederic Perez said:

I agree with David Thompson. If such a feature existed, I would have been able to avoid modifying VTK to suit my needs (In particular, I had to modify vtkSTLReader.cxx to be able to deal with vtkPoints being VTK_DOUBLEs instead of the default VTK_FLOATs. The gist of the matter was calling vtkPoints::New(VTK_DOUBLE) instead of vtkPoints::New()).

Add introspection support [updated]

2009-11-20T17:31:33-08:00

David Thompson said:

I believe in this context it, introspection is meant to provide some mechanism for determining what variables (and methods for accessing them) exist for a given object. For instance, if you have

vtkObject* obj;
cout << obj->GetClassName() << "\n";

You might see that you have a vtkPlane subclass of vtkObject, but without performing a downcast to the vtkPlane class, you have no way of knowing that the object has Normal and Origin members that are 3-tuples of doubles. This would provide a way for determining that information without downcasting, most likely by adding a few new methods to vtkObject.

Add introspection support [updated]

2009-11-20T10:48:08-08:00

daviddoria said:

Here is the wikipedia definition:
"type introspection is a capability of some object-oriented programming languages to determine the type of an object at runtime"

Anyone care to elaborate?

Make underlying datatype of vtkPoints configurable via cmake (VTK_FLOAT => VTK_DOUBLE) [updated]

2009-11-20T09:47:06-08:00

David Thompson said:

Rather than a compile-time default, it might be nice to have a static member variable to hold a default array type:

int vtkPoints::StorageType = VTK_FLOAT;

That way you could change it once in main() and then use the same VTK build for many programs that assume it will hold floats. Also, this may involve work beyond changing vtkPoints since some filters may assume they can SafeDownCast to a vtkFloatArray and access the data directly.

Make underlying datatype of vtkPoints configurable via cmake (VTK_FLOAT => VTK_DOUBLE)

2009-11-20T08:28:05-08:00

Michael Bachmann suggested:
When triangulating large volumes, the underlying data type float reaches quickly its limits. Rounding the data to float makes details disappear in case a triangle is far away from the origin of the coordinate system. In case float was choosen in the past for performance reasons, this shouldn't be a reason anymore with modern computers (of course the occupied memory will be twice as much).

Create a matrix class and use it for vtkMath function interfaces [updated]

2009-11-03T05:24:48-08:00

Bryn wrote a couple of nice helper functions for dealing with matrices: http://www.vtk.org/Wiki/Compute_eigenvalues_and_eigenvectors_of_a_symmetric_matrix These should be wrapped into a class so the interfaces to many of the vtkMath functions (Jacobi(), for example) do not require the user to use ** variables, but rather can easily interface with a matrix using an (r,c) type notation.

daviddoria said:

Ah yes, I was thinking of ITK, my mistake. I don't follow what you are saying about using the *Arrays in the pipeline? Could there not be subclasses that function much as vtkMatrix4x4 does but just for vtkMatrixNxN type situations? And the main point is still that vtkMath functions should accept "reasonable" style matrices like this insetad of **array style data.

Create a matrix class and use it for vtkMath function interfaces [updated]

2009-11-02T19:19:20-08:00

David Thompson said:

@daviddoria: The point of using vtkArray and vtkArrayData is that VTK pipelines could then be used (in addition to custom hand-written code now employed) to generate matrices for camera and actor movements, etc. Also, I do not believe VNL is currently distributed as part of VTK. Perhaps you are thinking of ITK?

Better documentation [updated]

2009-10-31T11:14:40-07:00

Make a pass through VTK classes to ensure all methods and arguments are clearly documented.

Ben Held said:

I think it would be very useful if the documentation was clear about the default values for the various flags one can set. Often we have to dig around in the source code to find this.

Better documentation [updated]

2009-10-31T08:55:37-07:00

Make a pass through VTK classes to ensure all methods and arguments are clearly documented.

daviddoria said:

The library that needs to be linked to to use a class is also an important part of the documentation that is missing.

Create a matrix class and use it for vtkMath function interfaces [updated]

2009-10-31T08:51:09-07:00

daviddoria said:

Yes, vtkDenseArray can be used as a matrix (or tensor) but my point is that none of the matrix functions currently use it. And it doesn't provide GetColumn/GetRow type functions. Everything that vtkMatrix4x4 has could be extended to more general size matrix/tensors. Could we just write wrappers for VNL classes (vnl_matrix, vnl_vector, etc)? Or even just use VNL directly since it is already packaged with VTK? What is the advantage to reimplementing everything from VNL in VTK?

Declarative API [updated]

2009-10-30T12:13:04-07:00

David Thompson said:

I dunno, I kinda like it. But I also like the idea of SetXXX() returning true or false depending on whether XXX was changed or not.

Create a matrix class and use it for vtkMath function interfaces [updated]

2009-10-30T12:10:38-07:00

David Thompson said:

A storage class (vtkArray and its vtkDataObject container vtkArrayData) for tensor-type storage which is a superset of matrices already exists. Also, VTK/Utilities/alglib already contains an eigenvector solver (for dense matrices... it provides its own matrix class which can handle zero-copy references to arrays of doubles). But I do agree a more generic vtkMath interface to these kinds of things would be nice.

Create a matrix class and use it for vtkMath function interfaces

2009-10-30T08:35:46-07:00

daviddoria suggested:
Bryn wrote a couple of nice helper functions for dealing with matrices: http://www.vtk.org/Wiki/Compute_eigenvalues_and_eigenvectors_of_a_symmetric_matrix These should be wrapped into a class so the interfaces to many of the vtkMath functions (Jacobi(), for example) do not require the user to use ** variables, but rather can easily interface with a matrix using an (r,c) type notation.

Declarative API [updated]

2009-10-27T09:42:41-07:00

daviddoria said:

Does it do anything besides prevent typing "sphere" again on each line? e.g.
sphere->SetRadius(10);
sphere->SetThetaResolution(100);
sphere->SetPhiResolution(100);

Add signal/slot support like Boost or Qt [updated]

2009-10-26T17:51:08-07:00

Replace or extend the current observer pattern with signals and slots.

David Thompson said:

Another implementation to consider is libsigc++ (http://libsigc.sourceforge.net/). Unlike Qt signals, it does not require a tool like moc to preprocess source code.

Include vtkInformation in file writers

2009-10-26T17:29:27-07:00

David Thompson suggested:
Datasets and arrays currently have a vtkInformation object that can be used to store metadata, but none of it is written to disk. Programmers should be able to mark information objects as serializable and all serializable information should be written to disk. Filters could easily annotate datasets with information that would accelerate processing when reloaded.

Add units to array types

2009-10-26T17:25:28-07:00

David Thompson suggested:
Store unit information for each *component* of an array. This could be done easily with vtkInformation objects. For example, the vtkDataArray used by a vtkPoints objects might have 3 vtkInformation objects (one for x, y, and z) specifying the units in which each component's values are specified ('km', 'ft.', 'furlong'). A filter could then perform unit conversions for arrays or even do fancy analysis like using Buckingham Pi theory to determine combinations of arrays to examine.

Provide parameter pipeline in addition to data pipeline

2009-10-26T17:12:07-07:00

David Thompson suggested:
Provide a way for filter outputs to set or override the parameter values of other filters. For instance, it should be possible (without writing a new class) to have a vtkDescriptiveStatistics filter's mean and median values used as the contour values of a vtkContourFilter.

Use namespaces [updated]

2009-10-26T12:37:43-07:00

Put VTK in a namespace instead of relying on prefixes for avoiding name collisions.

Francois Bertel said:

I would vote against. Namespaces solve nothing at all. They are just ugly C++ constructions.

Declarative API [updated]

2009-10-26T12:32:55-07:00

Francois Bertel said:

I would vote against too. For the reason invoked above and for debugging reason, good luck to trace this kind of line.

Add support for shared memory parallelism

2009-10-26T00:34:02-07:00

Stephane Ploix suggested:
It would be great if at least the most common filters (stream lines, contour, extract surface...) would take advantage of multiple cores without MPI.

Declarative API [updated]

2009-10-25T04:01:35-07:00

Tim Peeters said:

I would actually vote against this. It makes the code less clear/readable.