LabWindows/CVI Idea Exchange

At present CVI is missing a serious report printing facility that permits to create flexible, professional and good looking reports.

A quick search in CVI forum shows that periodically somebody posts questions about reporting but available instruments at the moment are not satisfactory in my experience.

As far as I can tell, a good reporting instrument:

1. Should integrate easily with CVI
2. Should be fully documented, with some example for the more typical types of reports (text + table, text + graph, text + image...)
3. Should not rely on external programs (some customers have rigid constraints on the software installed on equipment machines; additionally, asking them to have full Word or Excel or Diadem installed only for reporting is just not serious)
4. Should not rely on ActiveX controls to be licensed separately (same as above)
5. Should permit to include text and graphics (images, graphs...) and define headers, footers, page numbering and other common features normally present in reports
6. Should output data directly to the printer or in PDF format
7. Should have a preview facility both for development and for the user (something that NIReports hasn't and will never have)

Starting CVI the IDE uses cpu resources even if sleeping, i.e. doing nothing except waiting for user input. It seems that the IDE is also using the scheme of SetSleepPolicy...

Today most other software does better and I would like to see an improved behavior: use cpu (and thus energy...) only if something actually needs to be done

We have recently dropped CVI (as of 2009) as an option for use with our many data visualization applications.  The graphic performance is just too slow and clunky to put up with any longer and gets worse as we add features or try to make 'native looking' applications (that resize, animate, etc).  

Things like dragging/updating cursors is noticably clunky when you have more than one graph updating (linked cursors across more than one graph).  

Updating datasets in large tables is slow enough to watch it step through the rows.  Even using suggest tips like using ATTR_CTRL_VAL instead of SetTableCellVal, when a large table has to update... it's painfully noticeable. Basically any operation that updates a large portion of the UI.

Another example, try to resize and move controls (as most other applications do) on the EVENT_PANEL_SIZING?

I'm going to go out on a limb and guess that CVI doesn't use any graphics card acceleration? since workstation or netbook doesn't seem to make much difference in graphic performance.  

Our clients notice when our applications look 'clunky' and 'slow' when compared to smooth, responsive apps/interfaces from competitors.  It's often the little things that make a big difference in appearance.

Greg

It was a nice surprise when CVI provided clang as an external optimizing compiler. In the meantime, however, the initial clang version 1.0 has been significantly improved and now is at version 3.0 - but not for CVI users...

I would suggest that NI provides a current Windows binary of the compiler for everyone with a legal copy of CVI2010 or later. As the release cycles of CVI are quite long it would be convenient to obtain, on a biannual interval, interim updates of clang.

It would be convienent at times to have a way to know if timer callbacks had been suspended by another part of the program by 

SuspendTimerCallbacks(), or if timers are running again from ResumeTimerCallbacks().  As far as I can tell there is currently no way to know this in CVI without manually keeping track of the last suspend/resume function called.  Thanks.

One thing, I'm comming accross with very often is, that the drawing updates of Table controls are very slowly, Sometimes, they bring the system to hanging, whithout increasing the processor load, and User Interface events (e.g. Commit events) are not recognized quick enough (up to 30 s delay, depends also on other events, e.g. Timer, HW events etc.).

On most of my projects, I was changing the Table controls to Tree controls, which are much more quicker in drawing updates. But sometimes, I need the Table features (e.g. Ring cells, picture cells etc.), so I'm not able to change the Table into a Tree.

According my expierience, Table controls should be updated every 2 s and Tree controls are able to be updated every 200 ms or faster without waiting for User Interface Events.

You should make Table controls nearly as quick as Tree controls...

Thanks

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.

My 2000 dollar worth, run of the mill desktop PC has 4 teraflop of brute computation power hiding in 4 GPUs. None of which is accessible for my programs I develop in Labwindows.

Shame!

With the release of the new OpenCL it is possible to generate a "platform independent" GPU computing library. That would place Labwindows on the same or better footing than Labview that already has some GPU computing support.

The advantages are obvious: huge gain in data processing speed, real-time application with streaming data,  pattern-recognition (video) applications, image processing, data-parallel tasks in (technical) modeling arena.

I am playing with some optimization algorithms (genetic algorithms, evolutionary algorithms) that benefit and show amazing gains since they are ideal for data-parallel applications! Currently working on the specs for a new type of controller that would optimize several parameters to figure out the state of the tissue culture (expanding, producing, overgrowing, etc.) to maximize productivity and to calculate the optimal settings using evolutionary algorithms... Any complex process control could take advantage of this kind of applications -currently not available- because of computational limitations. Had a previous optimization task that would have taken 150,000 years to complete using a brute force algorithm on a "monofilament" CPU-based application. Converted it to a genetic algorithm and it gives me a good enough solution in 3-4 days on the same standard PC. Now, with GPU, that problem could be solved in fifteen minutes while expanding the evolutionary depth and finding better solutions using even more complex fitness functions.

Ask yourself what do you want: tinkering with the conveniences of the IDE that already does the job well enough; or open the door to new landscapes that could be conquered by using the simple elegance and effectiveness of LabWindows and the power of GPUs?

The exit() function will make the application always return 0, no matter what value is passed to the function.  Per the documentation:

Thanks.

Comparison between floating point numbers is best done using FP_Compare() - see CVI help for details.

Often you need to choose the maximum (or the minimum) of the two floating point numbers, and the most common approach is:

if (a > b) {

choose a

} else {

choose b

}

If you use FP_Compare instead of ">" you'll notice that FP_Compare is much slower than ">" (because it involves calculation of the ratio between the two numbers). This is extremely evident if you have to choose the maximum of several couples of numbers.

I think that the maximum (or the minimum) between two floating point numbers could be found in a more effective way, comparing the exponents of IEEE representation (for example), and calculate the ratio only if the exponents are equal.

For this reason I suggest two new functions FP_Max() and FP_Min() that would much more performant than the easy approach.

Hello,

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

I hope CVI can maintain its owns Inter Process communication mechanism, such as the share memory, pipe, message queue, etc., not need to call the OS's API.

David

Not sure if any other IDEs use this, but it would be nice to select an option toif when cut and pasting code to somewhere else in the file, is if the indentation corrected itself.

So instead of absolute indentation from where it was at previously (column number from line), it would be relative indentation based on the first line cut/copy and pasted.