Architecture

1. The gnuplot control file: an ASCII (text) file with gnuplot commands.
2. The gnuplot data file: an ASCII (text) file containing the data to be plotted.

1. Let the VB 2005 program collect the information on the data that should be plotted.
2. In your program, connect to the datbabase and retrieve that data needed for the plot.
3. Let your program write both the gnuplot control file and the gnuplot data file.
4. Let (as in the example abobve) the control file point gnuplot to the data file.
5. Let your program 'call' the operating system asking it to start a gnuplot session and hand it over the control file.

CAREFUL!!! Since your instructor has no control over where you store the gnuplot control and data file on your system, you must make SURE(!!!!) that the references to those files --both in your program and in the gnuplot control file-- are correct. If you point gnuplot to the wrong file or into oblivion, it will not work correctly.

	Public Class Gnuplot
		
		Shared Sub Main()
		
			Dim control_file As String = "C:\TEMP\gnuplot_controlfile"
			do_the_plot(control_file)
			
		End Sub

		Shared Sub do_the_plot(ByRef control_file As String)
		
			Dim winroot As String
			Dim strCmdLine As String
			Dim strCmdParam As String

			winroot = System.Environment.GetEnvironmentVariable("SystemRoot")
			strCmdLine = winroot + "\system32\cmd"
			strCmdParam = "/C C:\""Program Files""\gnuplot\gp373w32\pgnuplot /noend " + control_file

			Try
				System.Diagnostics.Process.Start(strCmdLine, strCmdParam)
			Catch E As Exception
				Console.WriteLine(E.Message)
			End Try
			
		End Sub
	End Class

Study the above code carefully so you understand what's going on. This is tricky code but it nicely shows how, from inside a program, one can request the operating system to execute OS commands; a very common practice in system engineering.

Some explantion of the do_the_plot() code:

1. The string winroot is set to the root of your operating system using the system's environment variable SystemRoot (you do not have to set this variable; it's part of your OS).
2. Next, we build the OS command to start a command-line interpreter (winroot + "\system32\cmd).
3. Next, we set the string strCmdParam to the actual command we want to hand over to the command interpreter (the /C option says that a command will follow). Notice how we specify a command to start gnuplot, handing it over the gnuplot_controlfile. Notice how since the file path contains a space in "Program Files" (a very nasty habit that should be discouraged!), we must include double quoation marks.
   
4. Finally, we call the OS (System.Diagnostics.Process.Start) asking it to start the command-line interpreter (strCmdLine) passing it the actual command (strCmdParam).

In summary, from out of VB, we build a command to be executed by the OS command-line interpreter, then call the OS to start the command-line interpreter, handing it over the command to run inside the command-line interpreter... Makes sense?

Also, in the actual plot, note the gap in the curve for variable 'third.' Compare this with the NaN (Not a Number) entries in the data file.

Note that when gnuplot starts, it also starts a gnuplot interpreter window. Although in our case we'll very likely not make much use of this, you can use the menus in this window to fine tune the graph. You can also issue additional gnuplot commands through the interpreter.

Note that when we invoke gnuplot through a console application, gnuplot gets started from a (DOS) command shell that stays on the screen until we quit gnuplot. However, if you instead use the techniques learned in the lesson on VB.Net Visual Programming and launch the application from a Windows application, the command-line window does not show. To practice this, try writing a tiny Windows application with a form with but a single button called 'Plot.' Define an event handler for this button and let the event handler call the do_the_plot() subroutine.