In answer to a question by Matt Genovse, I posted a reply with a zip
file file attached, but haven't seen the reply on the list. I put the
zip file on web.telia.com/~u83105750 for anyone interested.

Marilyn
[EMAIL PROTECTED]

-------------------------------------------

Here's the question:

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
--

-----------------------------------------------------------------------------
Here's the reply:

I'm enclosing a "zip" file that contains a socket example program - it
makes a sending and receiving socket.  I'm also enclosing a dx module
written to open a haptic device, make the sockets, and start the
server loop going on the haptic device (HapticOpen - the server runs a
loop at a 1000 Hz).  The server code uses the socket to send data to
the another haptic module (HapticLocaiton) and this module outputs a
glyph at the location.  I also enclose a Makefile, mdf file and some
docs (.pdf).  This was written for Linux and has only been tested
under SuSe 9.2 with the SensAble omni phantom device, but might be a
useful example for your purpose.  Anyone is free to use the enclosed
if it is helpful.  I enclose two sample nets showing the use haptic
modules, but of course they won't run. Maybe you can get enough info
from what does appear.



Reply via email to