Hello,
I am working on a software tool for my Masters thesis / project using
OpenDX. I am currently going through all the OpenDX documentation
(users guide, programming reference, etc.) and examples, and though it
is extensive, I am still coming away with uncertainty regarding the best
approach to use for my implementation. Before I start any massive
coding effort on the visualization portion of the tool, I'd like to
solicit some guidance from more experienced users / developers. So here
we go....
My situation is the following: I have a tool that is collecting some
data, written entirely in C++. I'd like to have this tool be able to
send the data to DX (directly via shared memory or a socket, but not a
file). This tool does not need to provide any visualization or GUI
interface; rather, it only translates my data into data objects for use
by DX. Then, I plan to have a separate viewer (different OS thread /
main) that will interface with DX and be able to visualize this data
concurrently with the data being sent by the above tool.
So, to summarize, there are two threads: from one side, DX is receiving
data from a tool, and the other side, a viewer is allowing the user to
visualize / manipulate the data as it arrives. Obviously, it is
ultimately necessary to have the arriving data also sent to a file for
off-line visualization, but what I'm trying to stress is that I'd like
to visualize data as it is received by DX.
Is this scenario possible? I would imagine it is, but I'm thrown off by
the various libraries available (DXlite, DXcallm, DXL), and which to use
for the tool->DX connection, and the DX->viewer connection. I parsed
and run several DX samples, but still cannot ascertain the best
approach. For the tool->DX connection, it seems the DXlite should be
used per the programming guide since it is primarily meant to interact
with the data model. Does this then allow my viewer to run in a
separate thread to visualize this same data as it arrives? For the
DX->viewer connection, I have wavered which library (DXcallm or DXL)
should be used (#2 below).
Uncertainties / wish list:
1. It would be nice to have the ability for the viewer to connect to DX
either via shared memory (faster if viewing on same machine as tool is
running) OR socket (for remove viewing).....and to be able to select
this at run-time.
2. By using the DXLink library, it looks like any C/C++ code will
interface via script commands to DX. Conceptually, this seems slow
because of the parsing that must be implemented by DX (versus direct DX
library calls to achieve the same functionality). However, I like the
idea of DXL because it means I can take advantage of the DX Executive
caching, etc. This is in contrast to the DXcallm lib, where I don't get
the benefits of the DX Executive, but I have this non-script C++
interface to use. Could really use some guidance on this.
3. On a somewhat unrelated topic, during this process of visualizing
while data is received by the viewer, is it possible to remove data
points from the data model? In other words, the plan is to have data
sent to DX from the tool, which is adding data to the data model
(concurrent with visualizing the constantly updated data model).....but
is it possible for the tool to also remove data points from the data
model as well, without corrupting DX?
4. For the viewer, I am looking at using Trolltech Qt for my GUI
interface. I saw an opendx-users from 2003 where Alan Scheinine was
attempting this also. I am just saying this as an FYI, since maybe that
throws a monkey wrench in the system that I am not aware of. Obviously,
I'm planning to use Qt for its clean GUI and internal interfaces, and
relatively good GUI builder. Also, if anyone has any advice re: using
Qt & DX, I'd appreciate it (as I really only found the two opendx-users
posts via Google on the topic).
Again, any guidance or suggestions (or even sample code) would be
greatly appreciated. Thanks in advance for taking the time to read all
this.
Best Regards,
Matt Genovese
University of Texas at Austin
--
