LabWindows/CVI Idea Exchange

Community Browser
About LabWindows/CVI Idea Exchange

Do you have a feature idea for how to improve LabWindows/CVI? Submit and vote on ideas now!
  1. Browse by label or search in the LabWindows/CVI Idea Exchange to see if your idea has previously been submitted. If your idea exists, be sure to vote for the idea by giving it kudos to indicate your approval!
  2. If your idea has not been submitted click New Idea to submit a product idea. You should submit a separate post for each idea. Watch as the community gives your idea kudos and adds their input.
  3. Give kudos to other ideas that you would like to see implemented!
  4. NI R&D will review ideas that have been submitted and update the status.

Note: the LabWindows/CVI Idea Exchange is not the appropriate forum to submit technical support questions.

The LabWindows/CVI R&D team is committed to reviewing every idea submitted via the LabWindows/CVI Idea Exchange. However, we cannot guarantee the implementation of any LabWindows/CVI Idea Exchange submission.

Top Kudoed Authors
User Kudos Count
Showing results for 
Search instead for 
Did you mean: 
Post an idea

There are many library functions that return several parameters. Many of which you may not care about. Some functions allow you to pass NULL to ignore some returned parameters, but many do not.

For instance:

LinFit (X, Y, NbP, NULL, NULL, &Intercept, &Err);

if you are only interested in the Intercept and error values, will crash on run with a "Null pointer argument to library function" fatal error.

The way it's currently written , you have to (correctly) declare plenty of dummy arguments for your calls.

  • Analysis

It has been discussed a few times in the forum so it might be appropriate to also ask here for the implementation of a native polar plot, i.e. plot r versus theta, with radial grid lines and all the corresponding ingredients.


Extend function PoyFit() available in package Advanced Analysis Library regarding the fitting method.



Up to now the above mentioned function is available with fitting method "Least Square" only, which is not always the best approach depending on the data and fitting problem. The fitting method "Least Absolute Deviations" (LAD) resp. "Least Absolute Residuals" (LAR) should be offered as well.



There already exists a LabView-VI called "General Polynomial" which offers the selection of the fitting method: see link

  • Analysis

The option tooltip is very good feature what is the problem is it is only for the controls. If I want to show tooltip for listbox then it is fine but what if someone wants to show tooltip for active rows. It simply doesn't. 


This is very basic but one of the disadvantage of labview over .NET.


This needs to be fixed

I apologize if this has already been addressed but this was determined as a issue years ago and forced us to implement a workaround.


We use PloXY for large data sets (up to 16 MB has become pretty standard lately). To address lag years ago, we pared the data to be viewed to 4000 data points in background code and send that to PlotXY. However, when the user zooms - which is always, you must then go back to the original data to find the new best 4K data points prior to plotting the new data. The code usually works well but there are instances where it can shutdown unexpectedly - not often enough to fight through friutfully though.


As for an truly automated perhaps a more logical course of action is to retrieve the panel size and use that for the data sizing. Regardless, it would be nice to use the CVI built in function and then subsequent zooming etc could be possible via standard functions.

When working with large programs, especially those with involved user interfaces and the pernicious CallControlCallback or CallPanelCallback functions, it becomes very difficult to follow the program flow when trying to trace a program through all of the various levels of subroutines.

A tool for leaving breadcrumbs, in the order visited, could be very helpful. Right now I use the "breakpoints" as a sort of hyper-bookmark, since the breakpoint facility in LabWindows shows the line number and has the "go to breakpoint" capability in the dialog box. However, this is of limited utility since the dialog box sorts the breakpoints by line number and file, not in order of placement. The bookmark facility doesn't show line numbers nor does it have the goto capability.


What is needed is a way of showing the program flow, through routines, in the order visited, in a way similar to the "stack trace" window, except that it needs to be able to show multiple levels simultaneously. This could be done using the existing bookmark facility with the addition of a few items. 1) show file names and line numbers in the bookmark display; 2) allow them to be shown in the order that they were entered, not sorted by line number; 3) add the go-to capability so that I can jump to the location of any bookmark directly.


For instance, right now I'm trying to solve a memory problem. A dynamically allocated buffer is being de-allocated before being used, or at least when the error pops up the routine is trying to write to a NULL pointer. I've got to trace through from the starting point and try to understand where in the flow the buffer is being freed and why it's being freed before being written to. Since there are about a half-dozen levels of subroutines, trying to remember what the program flow is and where I'm coming from in trying to trace it can be difficult.


Right now it is possible to have plots resembling histograms by choosing as plot style VAL_VERTICAL_BAR.


However, at present the width of these bars can only be adjusted by changing the line thickness in pixels (ATTR_PLOT_THICKNESS)


From a users point of view it would be more useful having the possibility to specify the width in units of the x axis.


Explanation: Say one is plotting an xy graph, with the data equally spaced and in incremetns of 1. If the x scale is 0-100 there would be 100 thin lines which may be appropriate in most cases. If the x scale is 0-5 there would be only five thin vertical lines. This appearance is very much different from what one would expect from an histogram. The suggestion is to set the width of the histogram bars to say +/- 0.4 x units, then there would be nice bars ranging from 0.6-1.4, 1.6-2.4, etc. in the case of an axis scale of 0-5, and the width of the bars would shrink accordingly if the axis scale is 0-100; in this case, there would be 100 rather thin lines resembling more or less the current appearance.


So in effect this suggestion is about an automatically adjusting line width (right now it is not possible to implement it manually because the line width is specified in pixels rather axis untis and is also limited to a maximum of 32 pixel.)


One step further could be to draw rectangles instead of lines with the possibility to independently choose line color and fill color.

In close analogy to the functions N_Dist (,)... for calculating the one-sided probability for a standard normal distribution I'd like to suggest test routines

B_Test () for binomial distributions and P_Test () for Poisson distributions.


Background: In many experiments, signals are not measured as a continuous curernt/voltage but are counted as individual events (photons, particles...) For 'rare' events the corresponding distribution function is binomial (few repetitions/sweeps) or Poisson (many repetitions).


In such cases using a Gaussian distribution is not always justified.

  • Analysis
0 Kudos

I have been looking for an easy way to resample data with either LabWindows/CVI or Measurement Studio and came across the Rational Resample VI for LabVIEW users. It would be great to have this functionality in LabWindows/CVI.


At the very least it would be good to have an Upsample method to insert zeros into a waveform/signal. Then an FIR interpolation filter can be used on the upsampled signal to interpolate the signal.

  • Analysis
0 Kudos



the Advanced Analysis Library provides some convenient functions for array operations; unfortunately some of them are available only for the 1D case and not for twodimensional arrays. While it is no big deal to add a loop I suppose that these AAL functions are speed-optimized, something that cannot be achieved when using the native CVI compiler.


Hence I'd like to suggest the addition of functions Clear2D, Set2D, Copy2D

0 Kudos

It would be convienent if there was a way to sort multiple arrays when the arrays are dependent on each other.  For example if there is an array of X values and an array of Y values, where the values make coordinates such as (x0, y0), (x1, y1), etc., and I want to sort the values by the X coordinate.  Or in other words it would be convienent if there was a function that could sort two (or more) arrays based upon the values in just one of the arrays.


The main reason I want this is to make nice looking X-Y plots with lines connecting the points, but the data is not in numerical order by X coordinate.

  • Analysis
0 Kudos

I'll continue my quest for better statistics support in CVI... While LabView provides a VI to calculate percentiles of an array, there is no built-in function in CVI


In case you are wondering what the purpose of percentiles is: it is as important as the standard deviation for robust statistics, i.e. instead of calculating the mean and the standard deviation one would choose to calculate the median (possible with CVI) and the 25 and 75 percentiles; the difference (sometimes called the interquartile distance, IQD) is a measure for the width of the distribution.


Robust statistics is valuable of one has to deal with outliers.


Hence I ask for a function to calculate percentiles; may be, if NI is generous, they may even supply a function to calculate IQD

  • Analysis
0 Kudos

Suprisingly, in the Advanced Analysis Library there is no general routine for numerically finding roots - except for polynomials.


In my opinion this is a quite frequent necessity and should not be missed in an advanced analysis library 

  • Analysis
0 Kudos

In the Advanced Analysis Library I'd like to see a function for efficiently computing binomial coefficients. The 'standard' definition


a! / ( b! * ( a - b )! )


is not efficient and susceptible to overflow. A better approach for example could be the calculation of ln (n!) using the gamma function as outlined in Numerical Recipes.