run oconv with standard input from process within C#

edit

There isn't anything that oconv is looking for as EOF, it just knows when it gets one. Can you share the code you're using to start the oconv process and write to the standard input. It might be as simple as closing a stream properly or exiting the process.

To think about EOF is a good start for sure, because most of the times the window of the oconv process is not closing itself (I'm not hiding it, yet), so it seems to wait for another input. I tried a lot with EOF but never got to the point where it runs. perhaps somebody can tell me what oconv wants for EOF? Thanks, Fabian

Code:

public string Execute(string program, string command, string input ) {
var proc = new Process()
{
 StartInfo = new ProcessStartInfo(program, command)
 {
  RedirectStandardInput = true,
  RedirectStandardOutput = true,
  UseShellExecute = false
 }
};
proc.Start();
proc.StandardInput.WriteLine(input);
proc.StandardInput.WriteLine((char)26); //EOF
proc.StandardInput.Flush();
proc.StandardInput.Close();

var result = proc.StandardOutput.ReadToEnd();

proc.WaitForExit();
proc.Close();

return result;

I also tried using Write() instead of WriteLine() with and without EOF. Even tried to use StreamWriter, but the result always stays the same. I'm using this program call also with rtrace and rcalc to input the evaluation points. There everything works fine...

maybe try switching the order of so that the process exits then read the result?

proc.WaitForExit();
var result = proc.StandardOutput.ReadToEnd();

Also thought about that. The octree files always miss some information, i.e. they look the same as the working ines but have a few lines in the end missing. But switching the two lines of code as suggested doesn't (sadly) change a thing.

Perhaps for an better understanding. I want to use these functions within Dynamo and created therefore a library (Illumyno on GitHub). It works fine for me if I'm writing all .rad and .oct files and then reuse them in the next node, but using Standard input and output instead would enable me to run all simulation within one Dynamo run instead of several ones.

This page uses a streamreader to read the output of a process. And also says that you have to do it in the order you've got to avoid deadlock (so my suggestion above was wrong). But maybe theres something about stream reader that allows it to continuously capture until the process exits? https://msdn.microsoft.com/en-us/libr...

Are you sure that the output from oconv is being handled in Windows' "binary mode?" There are (unfortunately) different modes for Windows files, and the default "text mode" changes <cr><lf> sequences to <lf> on output and vice versa on input if I remember right. Also, the character 26 <control-z> only marks the EOF in a text file. Binary files end on 128-byte boundaries (with garbage at the end) and Radiance just needs to know when to stop, so octrees and other binary files have a predictable length and don't look for EOF.

Thanks a lot for the advices. After a lot of triing to read and write in binary mode I finally end up in wirting the inputs to a file and running oconv on that within my function, allowing me to build up a whole Dynamo script without having to stop (which was the case in the previous appraoch). Though I'm still not fully satified with this, it works as an first attempt for me. Thanks you!

Yes I'm sure. I'm also fetching any exeptions from StandardError. Also if I write my "input" to a file and use this in oconv via the console everything works.

Just out of curiosity, what if in your workflow you take the input file and convert it back to standard input by "type"-ing it and then pipe that to oconv? Can you also write that piped STDOUT to a file, and compare it in a decent text editor alongside the output your function generates?

"type"ing the input file to oconv results also in a longer .oct. It is even a little bit longer than the one created from the files as parameter. But it ends in the same results as the working octree from files, without the truncated octree warning.

Python has a module to launch processes similar to what you are doing in C#. However, I found that its not always a good idea to implement piping with a wrapper. Sometimes it just makes sense to let Radiance and DOS-shell do their thing than transporting binary data (as in the case of Oconv) between different processes. You can write the commands to a .bat file and then launch the .bat file with your code in C#. You can always interrupt/intercept a .bat file by using the wait method to do any data processing in between.

Mostapha, who commented above, has created a fairly sophisticated wrapper/add-on for Radiance within his Honeybee plugin. Although it is written in Python for the most part, you can get a fair idea of what it takes to make Radiance work within such an environment...if you haven't already, check out..http://www.grasshopper3d.com/group/ladybug