[vtk-developers] Class design for spline visualizations
Lin M
majcjc at gmail.com
Mon Apr 6 16:50:00 EDT 2015
Hi Dr. Thompson,
Thank you. This is exactly what I need now! I'm using vtkMath::Binomial in
my implementation.
BTW, do you think my presumption which I wrote in the previous email for
the order of storage for P_i is proper?
Best,
Lin
On Mon, Apr 6, 2015 at 4:39 PM, David Thompson <david.thompson at kitware.com>
wrote:
> Hi Lin,
>
> If you are not familiar with git or the gitlab workflow for submitting
> branches, a project that would be an easy first step is to memoize[1] the
> vtkMath::Factorial function (which along with vtkMath::Binomial) could be
> used to compute coefficients for the Bernstein-Bezier polynomial.
>
> 1. cd /src
> git clone git at gitlab.kitware.com:yourAccount/VTK.git
> cd VTK
> 2. git checkout -b memoize-factorial
> 3. Modify vtkMath.{h,cxx} to memoize the factorial function and test it.
> 4. git commit -a
> 5. Assuming your fork of VTK is the remote named "origin", run
> git push origin memoize-factorial
> 6. In a browser, visit https://gitlab.kitware.com/VTK/VTK and submit a
> merge request (which indicates you want us to merge your memoize-factorial
> branch into VTK's master branch).
>
> David
>
> [1]: http://en.wikipedia.org/wiki/Memoize
>
> >> I have written a simple class to evaluate interpolated coordinates. How
> can I submit the code for test?
> >
> > Please create an account on https://gitlab.kitware.com/ . You can then
> fork the VTK repository https://gitlab.kitware.com/vtk/vtk and push
> branches to your fork of VTK for me and others on the mailing list to
> examine.
> >
> > Thanks,
> > David
> >
> >
> >> On Mon, Apr 6, 2015 at 11:17 AM, Lin M <majcjc at gmail.com> wrote:
> >> Yes, I got it now. :-)
> >>
> >> The only left thing is a presumption that how control points are
> arranged.
> >> My opinion is that the control points are stored in this order:
> >>
> >> P_{0, 0, 0};P_{1, 0, 0};...;P_{degree[0], 0, 0};
> >> P_{0, 1, 0};P_{1, 1, 0};...;P_{degree[0], 1, 0};
> >> ...
> >> P_{0, degree[1], 0};P_{1, degree[1], 0};...;P_{degree[0], degree[1], 0};
> >> P_{0, 0, 1};P_{1, 0, 1};...;P_{degree[0], 0, 1};
> >> ...
> >> P_{0, degree[1], degree[2]};P_{1, degree[1],
> degree[2]};...;P_{degree[0], degree[1], degree[2]};
> >>
> >> On Mon, Apr 6, 2015 at 10:55 AM, David Thompson <
> david.thompson at kitware.com> wrote:
> >> Hi Lin,
> >>
> >> One last correction: P_i will have 4 components per tuple. The outputPt
> array may have either 3 or 4 components per tuple (depending on whether you
> perform the projection division operation or not).
> >>
> >> David
> >>
> >> On Apr 6, 2015, at 10:53 AM, David Thompson <david.thompson at kitware.com>
> wrote:
> >>
> >>>> In the function:
> >>>> void InterpolateOnPatch(vtkDataArray* outputPt, vtkDataArray* P_i,
> double* r);
> >>>
> >>> Sorry, I see that I did not specify quite enough information. In
> addition to P_i, you will also need to know how the control points are
> arranged. So, a proper signature could be
> >>>
> >>> void InterpolateOnPatch(vtkDataArray* outputPt, int dim, vtkDataArray*
> P_i, int* degree, double* r);
> >>>
> >>> where
> >>>
> >>> outputPt is a VTK data array to hold interpolated points.
> >>> It will have 3 components; you should use InsertNextPoint()
> >>> to add the 3-D coordinates mapped from r by the patch.
> >>> dim is the dimension of the parameter-space.
> >>> This is the size of the arrays named r and degree.
> >>> P_i is a VTK data array of control point coordinates.
> >>> It will have 3 components per tuple.
> >>> The number of tuples will be the product of the entries
> >>> in degree + 1. For example, if dim == 3, then P_i should
> >>> have (degree[0] + 1)*(degree[1] + 1)*(degree[2] + 1) tuples.
> >>> degree is an array of integer values specifying the degree
> >>> of along each parametric coordinate in the patch.
> >>> When dim == 1, degree has a single entry specifying the
> >>> degree of a curve (degree[0] == 1 -> linear, degree[0] == 3
> -> cubic).
> >>> r is an array of parametric coordinates specifying a single
> point
> >>> on the patch. It is of length dim.
> >>>
> >>> I am working on a test that will pass this function curve, surface,
> and volume patches of different degree including some well-known test cases
> like this biquartic sphere of parametric dimension 2 (dim == 2):
> >>>
> >>>
> http://content.lib.utah.edu/utils/getfile/collection/uspace/id/3043/filename/2155.pdf
> >>>
> >>> Does this make more sense?
> >>>
> >>> David
> >>>
> >>>> 1. Do I assume that i and r are both a 3-vectors here? If not, how do
> I determine the dimension of that?
> >>>> 2. Do I assume the highest degree of each polynomial dimension is
> equal to each other, thus the maximum of (i,j,k) for P_{i,j,k} can be
> calculated by max(i)=max(j)=max(k)=P_i->GetNumberOfTuples()/3?
> >>>> 3. Even I know the maximum of (i,j,k), what's the order of storage
> for the P_i in memory?
> >>>>
> >>>> Best,
> >>>> Lin
> >>>>
> >>>>
> >>>> On Fri, Apr 3, 2015 at 12:56 PM, David Thompson <
> david.thompson at kitware.com> wrote:
> >>>>> My name is Lin. I'm interested in the project idea about spline
> visualizations from VTK/GSoC2015. I hope I can make some works on this
> topic and I understand that many preliminary discussions are needed for a
> new set of classes in VTK. This mail will contain the conversations about
> class design for this project.
> >>>>
> >>>> Hi Lin,
> >>>>
> >>>> One of the first things we should discuss is notation so we can be
> consistent and avoid confusion.
> >>>>
> >>>> Notation
> >>>> --------
> >>>>
> >>>> One of the first steps will be interpolating points on Bézier patches
> given control points, P_i, and parametric coordinates, r. Note that i and r
> may be 1-, 2-, or 3-vectors depending on whether the patch is a curve,
> surface, or volumetric region. Because VTK assumes points always have 3-D
> coordinates, each control point will always have 4 coordinates (3 spatial
> coordinates plus a denominator because we are interested in rational
> functions). So, a simple bilinear surface patch might be defined by
> >>>>
> >>>> P_{0,0} = (0,0,0,1)
> >>>> P_{1,0} = (1,0,2,1)
> >>>> P_{1,1} = (1,1,0,1)
> >>>> P_{0,1} = (0,1,1,1)
> >>>>
> >>>> and for r = (0.5, 0.5), P(r) = (0.5, 0.5, 0.75, 1). P(r) can be
> projected to a 3-D point by dividing the first 3 coordinates by the fourth.
> Let's call the projected version P'(r) = (0.5/1, 0.5/1, 0.75/1).
> >>>>
> >>>> As the degree increases, more control points will be required. The
> example above is for a rectangular patch. Bézier patches may also be
> triangular or tetrahedral by using barycentric coordinates.
> https://en.wikipedia.org/wiki/B%C3%A9zier_triangle
> >>>>
> >>>> VTK background
> >>>> --------------
> >>>>
> >>>> Because we are dealing with rational patches, one of the first issues
> will be how control points are represented. The vtkPoints class assumes
> that points always have 3 coordinates (not 4 like our control points). We
> can
> >>>>
> >>>> 1. Assume that control points are specified with 2 things: a
> vtkPoints instance plus a vtkDataArray holding the denominators.
> >>>> 2. Create a new vtkControlPoints class that inherits from vtkPoints
> and allows for an extra coordinate.
> >>>> 3. Not use vtkPoints instances at all and store control points in a
> vtkDataArray with 4 components per tuple.
> >>>>
> >>>> I am leaning toward option 2. Note that these classes do not force a
> particular memory layout because of recent changes to the VTK array
> classes. So, another related issue is how the interpolation techniques can
> be written to allow alternative memory layouts so that isogeometric finite
> element simulations can specify the memory layout instead of forcing the
> simulation to adopt VTK's.
> >>>>
> >>>> It would be a good idea to read this wiki page:
> http://www.vtk.org/Wiki/VTK/InSituDataStructures (especially the "Mapped
> vtkDataArrays" section) to understand how the array classes have changed
> recent to allow different memory layouts.
> >>>>
> >>>> A good first step would be to write a few tests to perform
> interpolation of some simple 1-, 2-, and 3-D patches given control points
> in a vtkDataArray and using the vtkDataArrayIteratorMacro to access control
> point coordinates. I can provide some control points, parametric
> coordinates, and the correct interpolated point values if you provide a
> function like
> >>>>
> >>>> void InterpolateOnPatch(vtkDataArray* outputPt, vtkDataArray* P_i,
> double* r);
> >>>>
> >>>> that interpolates P_i(r) and stores the result in outputPt by calling
> outputPt->InsertNextTuple().
> >>>>
> >>>> David
> >>>>
> >>>
> >>
> >>
> >>
> >
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://public.kitware.com/pipermail/vtk-developers/attachments/20150406/c01fd927/attachment-0001.html>
More information about the vtk-developers
mailing list