Archive

Posts Tagged ‘code’

WinSCP Wrapper (Managed c++)

June 14th, 2010 Jerdak No comments

Here is a little code I wrote to help me access WinSCP via Managed C++.

The code is extremely simple.  A worker thread is spawned which reads from a message packet.  Even though this class uses a worker thread it is technically synchronous.  You can only run a new WinSCP command when the last one has been completed.  The basic logic is thus:  Assign Command to WinSCP -> WinSCP Runs Command Automatically -> WinSCP Returns to a MessageComplete delegate -> Assigned a Command to WinSCP

There isn’t a particular reason for my lack of true asynchronous support other than a lack of time for proper coding.  The time saved by running commands from a queue is negligible given how little I do with the data I request in my apps.  That’s also why you’ll see the beginnings of thread safety (locking) but why it isn’t complete.  Since everything has to run in a specific order there is no need to lock any variables.

The code for this project is being attached directly to this post rather than in my SVN account.

Usage:

ref class ScpRun {
public:
	ScpRun(){
		_commandList = gcnew System::Collections::Generic::List<WinScpCmd^>;
		_scp = gcnew WinScpWrapper();
		_this = this;
		_account = gcnew String("");
	};
	bool Done(){return _bDone;}
	void Run();
	void Stop(){_this->_scp->RequestStop();}
 
	///Get/Set WinSCP account name
	property String ^Account {
		String ^ get(){return _account;}
		void set(System::String ^ s){_account = s;}
	};
protected:
 
	///WinSCP message is complete
	static void ScpMessageComplete(System::Object ^sender, WinScpEventArgs ^args);
private:
 
	///WinSCP wrapper API
	WinScpWrapper ^_scp;
 
	///Command stack (each return message from WinSCP)
	System::Collections::Generic::List<WinScpCmd^> ^_commandList;
 
	///Self-referential pointer for worker thread
	private: static ScpRun ^_this;
 
	///Worker thread complete?
	bool _bDone;
 
        ///WinSCP account name
	System::String ^_account;
};

There isn’t much going on here. We create a generic WinSCP handler class. In my example we create a command stack (just a list), each successive command is sent to WinSCP when the previous one is complete.

ScpRun::Run

void ScpRun::Run(){
	_bDone = false;
	{	///Create command list
 
                //The very first call MUST be to open an account name.  I suggest setting up an easy name using WinSCP that you can reference here.
                _commandList->Add(gcnew WinScpCmd(WSC_OPEN,_account));
 
                //Next we'll add a command to print the current working directory	
		_commandList->Add(gcnew WinScpCmd(WSC_PWD,""));
 
                //Now lets dump the contents of our current directory
		_commandList->Add(gcnew WinScpCmd(WSC_LS,""));
 
                //Lastly be sure to kill your connection
		_commandList->Add(gcnew WinScpCmd(WSC_CLOSE,""));
	}
 
        //Pull the first command off our command stack and call WinSCP
	WinScpCmd ^tmp = _commandList[0];
	_commandList->RemoveAt(0);
 
        //Here we send our command to WinSCP, arguments are parsed by the class
	scp->wsc_call(tmp->Command,tmp->Arguments);
 
        //Be sure to assigned a MessageComplete callback function
	scp->WSCMessageComplete += gcnew WinScpWrapper::MessageComplete(&ScpRun::ScpMessageComplete);
 
        //Tell WinSCPWrapper it's time to start
        scp->RequestStart();
}

Again, all real simple code. We’ve added 4 commands to our command stack and we’ve sent the first off to be run. When that command is complete (successfully or not) it will push out an event to any MessageComplete handlers. I should note here that there isn’t any sort of timeout value. An assumption is made (wrongfully or not) that WinSCP will always return a value.

ScpRun::ScpMessageComplete

void ScpRun::ScpMessageComplete(System::Object ^sender, WinScpEventArgs ^args){
	//Arguments only have 2 states, success or failure.
        if(!args->_bSuccess){
		switch(args->_trigger){
			case WSC_PWD:
			case WSC_LS:
			case WSC_OPEN:
			case WSC_CLOSE:
				printf("Crap-sicle our command has failed.");
				break;
			default:
				break;
		}
		printf("[Command %s failed.]\n",args->_fullCommand);
	} else {
		switch(args->_trigger){
			case WSC_LS:{
				break;
			case WSC_PWD:
				break;
			default:
				printf("Command %s complete.\n",args->_fullCommand);
				printf("   - Value: %s.\n",args->_value);
				break;
		}
	}
 
	///If command list contains more commands, run them.  (Demo only)
	if(_this->_commandList->Count > 0){
		WinScpCmd ^tmp = _this->_commandList[0];
		_this->_commandList->RemoveAt(0);
		_this->scp->wsc_call(tmp->Command,tmp->Arguments);
	} else {
		_this->_bDone = true;
	}
}

Here we handle return messages from our WinSCP wrapper. It would be advisable to add some code here to handle an error from WSC_OPEN that tells the command stack to stop issue commands and set _bDone to true;

The only remaining action is to run our handler class:

	ScpRun ^scp = gcnew ScpRun ();
	scp->Account		= "dummy_account_name";
	scp->Run();
 
	//loop until done
	while(!scp->Done()){
		Threading::Thread::Sleep(15);
	}
	//Tell SCP to stop which in turn tells our WinSCP wrapper to kill its worker thread.
	scp->Stop();

I should mention the WinScpWrapper files. There are some lines that look like the following:

#include <GIniWrapper.h>
//gcnew String(config.getValue.....

You’ll have to remove references to and replace any calls to ‘config.getvalue’ w/ raw values. You’ll see in my get value though that the 3rd argument is actually a default value, just use these. It’s important that you use the same delimiter and cmd_ender that I use. WinSCP, as far as I can tell, doesn’t return any sort of codes. When your command is complete nothing is sent to say as much. You might be able to search for blank lines but I wasn’t sure if these would show up in other commands. Instead what I’ve done is after I issue a command to WinSCP I issue an additional command w/ ‘__END_CMD__’ as the message. WinSCP won’t know how to parse this command but it will still be written to the process handlers output. In this way we can search for valid commands between subsequent ‘winscp>’ command line tags. It’s a kludge but it works.

Categories: Coding Tags: , , , ,

Bezier Patch

December 21st, 2009 admin No comments

bezier
No fanfare, no lengthy preamble, just the code to a bezier patch generator:

// Bezier.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <3DIO/3DIO.h>
#include <vector>
#include <string>
 
using namespace tdio_library;
using namespace std;
 
void create_patch(float step);
void save_patch(const string &name);
void load_bez(const string &name);
 
vector<vector3> pts;
vector3 ctrlPts[4][4];
vector<std::vector<int>> faces;
 
int main(int argc, char* argv[])
{
	load_bez("config.txt");
	if(argc >= 2)create_patch(atof(argv[1]));
	else create_patch(0.2);
 
	save_patch("test.obj");
	return 0;
}
void load_bez(const string &name){
	FILE *stream = fopen(name.c_str(),"r");
	char buffer[256];
	int ct = 0;
	while(!feof(stream)){
		if(fgets(buffer,256,stream)==NULL)break;
 
		float x[4],y[4],z[4];
		char ch;
		if(buffer[0] == 'c'){
			sscanf(buffer,"%c %f %f %f %f %f %f %f %f %f %f %f %f",&ch,&x[0],&y[0],&z[0],&x[1],&y[1],&z[1],&x[2],&y[2],&z[2],&x[3],&y[3],&z[3]);
			ctrlPts[ct][0] = vector3(x[0],y[0],z[0]);
			ctrlPts[ct][1] = vector3(x[1],y[1],z[1]);
			ctrlPts[ct][2] = vector3(x[2],y[2],z[2]);
			ctrlPts[ct][3] = vector3(x[3],y[3],z[3]);
			ct++;
		}
 
		if(ct >= 4)break;
	}
	if(ct != 4){
		printf("  - Warning, read %d control lines.  Should be 4\n",ct);
	}
	fclose(stream);
}
void save_patch(const string &name){
	FILE *stream = fopen(name.c_str(),"w");
	for(int v = 0; v < pts.size(); v++){
		fprintf(stream,"v %f %f %f\n",pts[v].x,pts[v].y,pts[v].z);
	}
	for(int f = 0; f < faces.size(); f++){
		fprintf(stream,"f %d %d %d\n",faces[f][0]+1,faces[f][1]+1,faces[f][2]+1);
	}
	fclose(stream);
 
}
vector3 get_bez_pt(float u, float v){
	double tmp = 0;
	double c[4] = {1,3,3,1};
	vector3 ret(0,0,0);
	for(int i = 0; i < 4; i++){
		for(int j = 0; j < 4; j++){
			tmp = c[i]*c[j] * pow(u,i) * pow(1-u,3-i)*pow(v,j)*pow(1-v,3-j);
			ret.x += ctrlPts[i][j].cell[0] *tmp;
			ret.y += ctrlPts[i][j].cell[1] *tmp;
			ret.z += ctrlPts[i][j].cell[2] *tmp;
		}
	}
	return ret;
}
void create_patch(float step){
	printf("-- Create Patch--\n");
	printf("  - Step: %f\n",step);
 
	for(float x = 0; x < 3; x+=step){
		for(float z = 0; z < 3; z+=step){
			vector3 pt = get_bez_pt(x/3,z/3);
			pts.push_back(pt);
		}
	}
	printf("  - nPts: %d\n",pts.size());
 
	int width = (float)(3.0f/step + 1.0);
	int height = width;
 
	printf("  - Height/Width: %d\n",height);
	int f = 0;
	for(int v = 0; v < pts.size(); v++){
		if(v+width+1 >= pts.size())break;
 
		if((v+1) % (int)width != 0 || v ==0){
			std::vector<int> tmp;
			faces.push_back(tmp);
 
		        faces[f].push_back(v);
			faces[f].push_back(v+1);
			faces[f].push_back(v+width);
			f++;
 
			faces.push_back(tmp);
			faces[f].push_back(v+1);
			faces[f].push_back(v+width+1);	
			faces[f].push_back(v+width);
 
			f++;
		}
	}
	printf("  - %d faces created\n",faces.size());
}

The 3DIO.h file can be found my open source repository. The function ‘create_patch()’ creates a uniform patch of triangles between 0 & 3 in the X and Z axes. Gradients should be chosen to be between this range, I recommend 0.09. Control points are loaded in the function ‘load_bez()’ from a configuration file that looks like so:

#row 0
c 0 5 0 0 0 1 0 0 2 0 0 3

#row 2 of control pts
c 1 0 0 1 10 1 1 -15 2 1 0 3

#row 3 of control pts
c 2 0 0 2 -5 1 2 25 2 2 0 3

#row 4 of control pts
c 0 0 0 3 0 1 3 0 2 3 0 3

Each row controls 4 control points. You can ignore the ‘c’ value and concentrate on the following 16 floating point values. Like so: c x1 y1 z1 x2 y2 z2…… I recommend modifying the Y values first. Messing with X/Z can have weird consequences. Output is saves as a very basic .obj file.

The code, as always, is provided “as is”, with little explanation. I suggest reading up on Bezier patches to get an idea of what the code is doing. I’m happy to answer questions like usual but do your homework.

Categories: Coding Tags: , , ,