void TopicController::inquire()
{
Poco::JSON::Object::Ptr pcfParameters;
if ( data().has("input") && data().isObject("input") )
{
pcfParameters = data().getObject("input");
}
else
{
pcfParameters = new Poco::JSON::Object();
setData("input", pcfParameters);
std::vector<std::string> parameters = getParameters();
// First parameter is queuemanager
// Second parameter can be a topicname. If this is passed
// the query parameter topicName is ignored.
if ( parameters.size() > 1 )
{
pcfParameters->set("TopicName", parameters[1]);
}
else
{
// Handle query parameters
pcfParameters->set("TopicName", form().get("TopicName", "*"));
}
pcfParameters->set("ExcludeSystem", form().get("ExcludeSystem", "false").compare("true") == 0);
if ( form().has("ClusterInfo") )
{
std::string clusterInfo = form().get("ClusterInfo");
pcfParameters->set("ClusterInfo", Poco::icompare(clusterInfo, "true") == 0 ? "true" : "false");
}
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
formElementToJSONArray("TopicAttrs", attrs);
if ( attrs->size() == 0 ) // Nothing found for TopicAttrs, try Attrs
{
formElementToJSONArray("Attrs", attrs);
}
if ( attrs->size() > 0 )
{
pcfParameters->set("TopicAttrs", attrs);
}
if ( form().has("CommandScope") )
{
pcfParameters->set("CommandScope", form().get("CommandScope"));
}
if ( form().has("QSGDisposition") )
{
pcfParameters->set("QSGDisposition", form().get("QSGDisposition"));
}
if ( form().has("TopicType") )
{
pcfParameters->set("TopicType", form().get("TopicType"));
}
handleFilterForm(pcfParameters);
}
TopicInquire command(*commandServer(), pcfParameters);
setData("data", command.execute());
}
String8 AudioSystem::getParameters(const String8& keys)
{
return getParameters(AUDIO_IO_HANDLE_NONE, keys);
}
void AdjustLevelsPopup::apply()
{
//Retrieve parameters
int in0[5], in1[5], out0[5], out1[5];
getParameters(in0, in1, out0, out1);
//Operate depending on the selection kind
TCellSelection *cellSelection = dynamic_cast<TCellSelection *>(TSelection::getCurrent());
if (cellSelection) {
std::set<TRasterImage *> images; //Multiple cells may yield the same image...
int r0, c0, r1, c1;
cellSelection->getSelectedCells(r0, c0, r1, c1);
TXsheet *xsheet = TApp::instance()->getCurrentXsheet()->getXsheet();
bool oneImageChanged = false;
TUndoManager::manager()->beginBlock();
{
int c, r;
for (c = c0; c <= c1; c++) {
for (r = r0; r <= r1; r++) {
const TXshCell &cell = xsheet->getCell(r, c);
TRasterImageP rasImage = (TRasterImageP)cell.getImage(true);
if (!rasImage)
continue;
if (images.find(rasImage.getPointer()) != images.end())
continue;
TRasterP ras = rasImage->getRaster();
if (!ras)
continue;
images.insert(rasImage.getPointer());
oneImageChanged = true;
TUndoManager::manager()->add(new AdjustLevelsUndo(in0, in1, out0, out1, r, c, ras->clone()));
TRop::rgbmAdjust(ras, ras, in0, in1, out0, out1);
TXshSimpleLevel *simpleLevel = cell.getSimpleLevel();
assert(simpleLevel);
simpleLevel->touchFrame(cell.getFrameId());
simpleLevel->setDirtyFlag(true);
IconGenerator::instance()->invalidate(simpleLevel, cell.getFrameId());
}
}
}
TUndoManager::manager()->endBlock();
if (oneImageChanged) {
close();
return;
}
}
TFilmstripSelection *filmstripSelection = dynamic_cast<TFilmstripSelection *>(TSelection::getCurrent());
if (filmstripSelection) {
TXshSimpleLevel *simpleLevel = TApp::instance()->getCurrentLevel()->getSimpleLevel();
if (simpleLevel) {
std::set<TFrameId> fids = filmstripSelection->getSelectedFids();
bool oneImageChanged = false;
std::set<TFrameId>::iterator it = fids.begin();
for (it; it != fids.end(); it++) {
TRasterImageP rasImage = (TRasterImageP)simpleLevel->getFrame(*it, true);
if (!rasImage)
continue;
TRasterP ras = rasImage->getRaster();
if (!ras)
continue;
oneImageChanged = true;
TRop::rgbmAdjust(ras, ras, in0, in1, out0, out1);
simpleLevel->touchFrame(*it);
simpleLevel->setDirtyFlag(true);
IconGenerator::instance()->invalidate(simpleLevel, *it);
}
if (oneImageChanged) {
close();
return;
}
}
}
DVGui::error(QObject::tr("The current selection is invalid."));
return;
}
template<> ScriptRGBA ScriptArguments::getParameter<ScriptRGBA>(unsigned int arg) const
{
RW_CHECK(getParameters().size() > arg+3, "Argument list too short to get u8vec4");
return ScriptRGBA(getParameter<int>(arg), getParameter<int>(arg+1), getParameter<int>(arg+2), getParameter<int>(arg+3));
}
template<> ScriptFloat ScriptArguments::getParameter<ScriptFloat>(unsigned int arg) const
{
return getParameters().at(arg).realValue();
}
/* This is the main routine. */
int
main(int argc, char** argv)
{
int last_argument_index;
tibrv_status return_code;
char* serviceStr = DEFAULT_SERVICE;
char* networkStr = DEFAULT_NETWORK;
char* daemonStr = DEFAULT_DAEMON;
tibrvMsg search_request;
tibrvMsg search_reply;
const char* server_subject;
static char request_subject[TIBRV_SUBJECT_MAX];
static char response_subject[TIBRV_SUBJECT_MAX];
tibrvMsg client_request;
tibrvMsgDateTime date_time_start, date_time_stop;
tibrv_f64 time_start, time_stop, elapsed;
tibrv_u32 i;
/* Parse the command line. */
last_argument_index = getParameters(argc, argv,
&serviceStr, &networkStr, &daemonStr);
if (last_argument_index < argc) {
requests = atoi(argv[last_argument_index]);
}
/* The TIB/Rendezvous machinery needs to be started. */
return_code = tibrv_Open();
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to open the TIB/Rendezvous machinery: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* A transport needs to be created. */
return_code = tibrvTransport_Create(&transport,
serviceStr, networkStr, daemonStr);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to create a transport: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
tibrvTransport_SetDescription(transport, program_name);
/* We create the message we will send in order to locate a server. */
return_code = tibrvMsg_Create(&search_request);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to create a search request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Set the send subject to locate our server. */
return_code = tibrvMsg_SetSendSubject(search_request,
SEARCH_SUBJECT);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to set the send subject of a search request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
fprintf(stdout,
"%s is searching for a server on subject %s...\n",
program_name, SEARCH_SUBJECT);
/* Send a request message to locate a server and receive its reply.
SendRequest is a synchronous call which uses a private queue to
receive its reply. No external dispatching mechanism is involved. */
return_code = tibrvTransport_SendRequest(transport,
search_request,
&search_reply,
SEARCH_TIMEOUT);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to locate a server: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/*
The search reply we receive from a server should contain a reply
subject we can use to send requests to that server.
*/
return_code = tibrvMsg_GetReplySubject(search_reply,
&server_subject);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to get the request subject of a search reply: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
strcpy(request_subject, server_subject);
fprintf(stdout,
"%s successfully located a server: %s\n",
program_name, request_subject);
/* Destroy the server's reply message to reclaim memory. */
return_code = tibrvMsg_Destroy(search_reply);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to destroy a reply to a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/*
Create response queue, an inbox point-to-point subject, and a listener
using that subject for responses from the server to a series of
messages.
*/
tibrvQueue_Create(&response_queue);
tibrvTransport_CreateInbox(transport, response_subject, TIBRV_SUBJECT_MAX);
return_code = tibrvEvent_CreateListener(&response_id,
response_queue,
serverResponse,
transport,
response_subject,
NULL);
if (return_code != TIBRV_OK)
{
fprintf(stderr, "%s failed to initialize response mechanism: %s\n",
program_name, tibrvStatus_GetText(return_code));
exit(1);
}
/* Start a dispatcher thread to dispatch response messages. */
return_code = tibrvDispatcher_CreateEx(&response_thread,
response_queue,
REQUEST_TIMEOUT);
if (return_code != TIBRV_OK)
{
fprintf(stderr, "failed to create response dispatcher--%s\n",
tibrvStatus_GetText(return_code));
exit(1);
}
/* Because this is only a test, we will repeatedly send the same request
message to the server. We'll change the data in the message each time.
*/
return_code = tibrvMsg_Create(&client_request);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to create a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Set the send subject to the server's (inbox) subject. */
return_code = tibrvMsg_SetSendSubject(client_request,
request_subject);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to set the send subject of a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Set the reply subject to our inbox subject, allowing a point-to-point
reply from our server. We won't use SendRequest, so we won't block
waiting for th reply. */
return_code = tibrvMsg_SetReplySubject(client_request,
response_subject);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to set the reply subject of a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
fprintf(stdout, "Starting test...\n");
/* We will time this test. */
tibrvMsg_GetCurrentTime(&date_time_start);
time_start = date_time_start.sec + (date_time_start.nsec / 1000000000.0);
for (i = 0; i < requests; i++)
{
/* Put some data into the message to the server. */
return_code = tibrvMsg_UpdateU32(client_request, "x",
((tibrv_u32) rand()));
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to update a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
return_code = tibrvMsg_UpdateU32(client_request, "y",
((tibrv_u32) rand()));
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to update a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Send a request message to the server. */
return_code = tibrvTransport_Send(transport,
client_request);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to send a client request: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
}
/* Report the number of messages sent and number received while sending. */
fprintf(stdout,
"%d request messages sent. %d messages received while sending.\n",
requests, responses);
tibrvDispatcher_Destroy(response_thread);
/* Dispatch loop - dispatches events from the event queue in the main thread,
in addition to the dispatcher thread created earlier. Note that if the
last message is dispatched from that thread while this loop is executing
its TimedDispatch call, the loop will exit only after it times out. The
total time will be the time required to receive all the replies plus the
REQUEST_TIMEOUT value. */
while ((responses < requests) &&
(tibrvQueue_TimedDispatch(response_queue, REQUEST_TIMEOUT) ==
TIBRV_OK));
/* Report the run statistics for this test. */
tibrvMsg_GetCurrentTime(&date_time_stop);
time_stop = date_time_stop.sec + (date_time_stop.nsec / 1000000000.0);
elapsed = time_stop - time_start;
if (responses >= requests)
{
fprintf(stdout, "%s received all %d server replies\n",
program_name, responses);
fprintf(stdout, "%d requests took %.2f secs to process.\n",
requests, elapsed);
fprintf(stdout,
"This result implies an effective rate of %.1f requests/second.\n",
((tibrv_f64) requests / elapsed));
exit_status = 0;
}
else
{
fprintf(stdout, "Received %d responses to %d requests.\n",
responses, requests);
exit_status = 1;
}
/* Destroy our listener event and dispatcher thread. */
tibrvEvent_Destroy(response_id);
tibrvDispatcher_Destroy(response_thread);
/* Destroy our queue. */
tibrvQueue_Destroy(response_queue);
/* Destroy our transport. */
tibrvTransport_Destroy(transport);
/* Close the Tibrv machinery and exit. */
tibrv_Close();
exit(exit_status);
}
template<> const char* ScriptArguments::getParameter<const char*>(unsigned int arg) const
{
return getParameters().at(arg).string;
}
bool dunnIndex::apply(const std::vector<dmatrix>& clusteredData,
double& index, const dmatrix& centroids) const {
int nbClusters=clusteredData.size();
double denominator=0.0;
int i,j;
l2Distance<double> dist;
dvector diameters(nbClusters);
parameters param;
param=getParameters();
// pointer to the function which implements the measure according to the
// parameters
double (lti::clusteringValidity::*diamFunc)(const dmatrix&) const;
#ifdef _LTI_MSC_DOT_NET_2003
// nasty bug in this version of the .NET compiler
#define QUALIFIER
#else
#define QUALIFIER <i::dunnIndex::
#endif
switch (param.diameterMeasure) {
case parameters::Standard:
diamFunc=QUALIFIER getStandardDiameter;
break;
case parameters::Average:
diamFunc=QUALIFIER getAverageDiameter;
break;
case parameters::Centroid:
diamFunc=QUALIFIER getAverageToCentroidDiameter;
break;
default:
diamFunc=QUALIFIER getStandardDiameter;
setStatusString("Unknown diameterMeasure in clusteringValidity\n");
return false;
}
// compute all diameters of all clusters
for (i=0; i<nbClusters; i++) {
diameters[i]=(this->*diamFunc)(clusteredData[i]);
}
denominator=diameters.maximum();
// pointer to the function which calculates the distance of the functions
// a pointer to a function is used, because the function will be called
// many times later
double (lti::clusteringValidity::*distFunc)
(const dmatrix&,const dmatrix&) const ;
// set pointer to function which is set by the parameter distanceMeasure
switch (param.distanceMeasure) {
case parameters::Minimum:
distFunc=QUALIFIER getMinimumDistance;
break;
case parameters::Maximum:
distFunc=QUALIFIER getMaximumDistance;
break;
case parameters::Mean:
distFunc=QUALIFIER getAverageDistance;
break;
case parameters::Centroids:
distFunc=QUALIFIER getCentroidDistance;
break;
case parameters::Interpoint:
distFunc=QUALIFIER getAverageInterpointDistance;
break;
default:
distFunc=QUALIFIER getAverageDistance;
setStatusString("Unknown distanceMeasure in clusteringValidity\n");
return false;
}
// compute the distances of all clusters to each other
int counter=0;
dvector distanceVector(static_cast<int>(.5*(nbClusters*(nbClusters-1))));
for (i=0; i<nbClusters; i++) {
for (j=i+1; j<nbClusters; j++) {
if (distFunc==QUALIFIER getCentroidDistance) {
distanceVector[counter]=dist.apply(centroids.getRow(i),
centroids.getRow(j));
} else {
distanceVector[counter]=(this->*distFunc)(clusteredData[i],
clusteredData[j]);
}
counter++;
}
}
distanceVector.divide(denominator);
index=distanceVector.minimum();
return true;
}
// return probability channel
bool probabilityMap2D::apply(const channel8& src1, const channel8& src2, channel& dest) const {
const parameters& param = getParameters();
point chnl1_size = src1.size();
point chnl2_size = src2.size();
// size of src1 equals src2 ?
if ( (chnl1_size.x != chnl2_size.x) || (chnl1_size.y != chnl2_size.y) ) {
setStatusString("probabilityMap2D: channels do not match");
return false;
}
// the color model MUST have 2 dimensions!
if (probabilityHistogram.dimensions() == 2) {
// resize probability channel
dest.resize(src1.size());
ivector theBin(2);
// compute first iteration
int y;
vector<channel8::value_type>::const_iterator srcIterator1, eit1;
vector<channel8::value_type>::const_iterator srcIterator2, eit2;
vector<channel::value_type>::iterator destIterator;
for (y=0;y<src1.rows();++y) {
srcIterator1 = src1.getRow(y).begin();
eit1 = src1.getRow(y).end();
srcIterator2 = src2.getRow(y).begin();
eit2 = src2.getRow(y).end();
destIterator = dest.getRow(y).begin();
while (srcIterator1 != eit1) {
theBin[0] = lookupTable[0][*srcIterator1];
theBin[1] = lookupTable[1][*srcIterator2];
(*destIterator)=static_cast<float>(probabilityHistogram.at(theBin));
srcIterator1++;
srcIterator2++;
destIterator++;
}
}
// compute all other iterations
if (param.iterations > 1) {
int i;
if (param.gaussian) {
gaussKernel2D<float> gk(param.windowSize,param.variance);
convolution convolver;
convolution::parameters convParam;
convParam.boundaryType = lti::Mirror;
convParam.setKernel(gk);
convolver.setParameters(convParam);
for (i=1;i<param.iterations;++i) {
convolver.apply(dest);
computeMap(src1,src2,dest);
}
} else {
squareConvolution<float> convolver;
squareConvolution<float>::parameters convParam;
convParam.boundaryType = lti::Mirror;
convParam.initSquare(param.windowSize);
convolver.setParameters(convParam);
for (i=1;i<param.iterations;++i) {
convolver.apply(dest);
computeMap(src1,src2,dest);
}
}
} // of (param.iterations > 1)
return true;
} // of (probabilityHistogram.dimensions() == 2)
setStatusString("probabilityMap2D: no models loaded");
return false;
}
// to get m
//================================================================================
double SANISAND_alpha_Eij::getm(const MaterialParameter& material_parameter) const
{
return getParameters(material_parameter, m_index);
}
/* This is the main routine. */
int
main(int argc,
char** argv)
{
tibrv_status return_code;
tibrvEvent request_event = 0;
char* serviceStr = DEFAULT_SERVICE;
char* networkStr = DEFAULT_NETWORK;
char* daemonStr = DEFAULT_DAEMON;
char disp_name[255]; /* string buffer */
int i, vcthreads=0;
serverRec* myServer;
/* Parse the command line and set up the transport parameters. */
getParameters(argc, argv, &serviceStr, &networkStr, &daemonStr, &vcthreads);
/* The TIB/Rendezvous machinery needs to be started. */
return_code = tibrv_Open();
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s failed to open the TIB/Rendezvous machinery: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Each 'server' manages multiple virtual circuits. We create
a server structure to do the bookkeeping. A more trivial example
could just handle one VC at a time. */
myServer = (serverRec*)malloc(sizeof(serverRec));
/* A network transport needs to be created. We listen for search
requests on this transport. */
return_code = tibrvTransport_Create(&myServer->server_transport,
serviceStr, networkStr, daemonStr);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s: failed to create a transport: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
tibrvTransport_SetDescription(myServer->server_transport, program_name);
/* This listener will pay attention to VC server searches. */
return_code = tibrvEvent_CreateListener(&myServer->search_event,
TIBRV_DEFAULT_QUEUE,
searchCallback,
myServer->server_transport,
SEARCH_SUBJECT,
(void*)myServer);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s: failed to create a server search listener: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Since we wish to create a unique identifier for this
server we will create an _INBOX. An _INBOX is unique
not only on this host, but in the entire TIB domain in
which it is running. If we want to extend this server
to receive commands on this _INBOX in the future it is
trivial to do so.
We will store this as our server_subject and send it
as our reply_subject in all control or protocol messages.
*/
tibrvTransport_CreateInbox(myServer->server_transport,
myServer->server_inbox,
TIBRV_SUBJECT_MAX);
return_code = tibrvEvent_CreateListener(&myServer->server_inbox_event,
TIBRV_DEFAULT_QUEUE,
serverControlInboxCallback,
myServer->server_transport,
myServer->server_inbox,
(void*)myServer);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s: failed to create a client request listener: %s\n",
program_name,
tibrvStatus_GetText(return_code));
exit(1);
}
/* Now a queue group to hold the queues for the VCs that we
have open */
return_code = tibrvQueueGroup_Create(&myServer->vc_queues);
if (return_code != TIBRV_OK) {
fprintf(stderr,
"%s: failed to create queue group for VCs: %s\n",
program_name, tibrvStatus_GetText(return_code));
}
/* Finally, thread(s) dispatching off of the queue group. We
can have a number of threads waiting on this one queue group
that will service all of the VC(s) and their individual
queues */
if (vcthreads>VC_THREAD_MAX) {
vcthreads = VC_THREAD_MAX;
fprintf(stderr,
"%s: Maximum threads is %d - using %d\n",
program_name, VC_THREAD_MAX, VC_THREAD_MAX);
}
else if (vcthreads <= 0) vcthreads = 1; /* need at least one */
for (i=0;i<vcthreads;i++) {
return_code = tibrvDispatcher_Create(
&myServer->vc_dispatchers[i],
myServer->vc_queues);
if (return_code != TIBRV_OK)
{
fprintf(stderr,
"%s: failed to create dispatcher thread: %s\n", program_name,
tibrvStatus_GetText(return_code));
}
sprintf(disp_name, "%s_%d", myServer->server_name, i);
return_code = tibrvDispatcher_SetName(
myServer->vc_dispatchers[i],
disp_name);
}
/* Display a server-ready message. */
fprintf(stderr, "Listening for client requests on subject %s.\n"
"Wait time is %.0f secs.\n%s ready...\n",
SEARCH_SUBJECT, SERVER_TIMEOUT, program_name);
/* If this server remains idle for more than the timeout value, exit. */
while (tibrvQueue_TimedDispatch(TIBRV_DEFAULT_QUEUE, SERVER_TIMEOUT) == TIBRV_OK);
/* Destroy our Tibrv objects and close the Tibrv machinery. */
tibrvEvent_Destroy(myServer->search_event);
tibrvEvent_Destroy(request_event);
tibrvTransport_Destroy(myServer->server_transport);
free(myServer);
tibrv_Close();
exit(0);
}
Baleog::Baleog(Sint16 xcord, Sint16 ycord, const ParameterMap& param):
Player(xcord,ycord,param) {
weapon=Weapon(-1,W_STRIKE);
/* Parameters */
if (hasParam(parameters,"anim_baleog_sword_left")) anim_baleog_sword_left=loadAnimation(getParameters(parameters["anim_baleog_sword_left"],':'));
else anim_baleog_sword_left=loadAnimation(scenario->imgcache->loadImage(8,"BaleogCyborg_Slash_left.png"),8,BP_MD,ATYPE_ONCE);
if (hasParam(parameters,"anim_baleog_sword_right")) anim_baleog_sword_right=loadAnimation(getParameters(parameters["anim_baleog_sword_right"],':'));
else anim_baleog_sword_right=loadAnimation(scenario->imgcache->loadImage(8,"BaleogCyborg_Slash_right.png"),8,BP_MD,ATYPE_ONCE);
if (hasParam(parameters,"audio_sword")) au_sword=scenario->sndcache->loadWAV(parameters["audio_sword"]);
else au_sword=scenario->sndcache->loadWAV("swrdsw2.wav");
}
bool JsonMSUMessage::parseSignUp(const char* message, std::string& serverErrorMsg)
{
cJSON *root = NULL, *data = NULL;
cJSON *status = NULL,
*user = NULL;
int userStatus = cJSON_True;
if ((message == NULL) || (strlen(message) == 0)) {
LOG.error("%s: invalid JSON message", __FUNCTION__);
return false;
}
if ((root = cJSON_Parse(message)) == NULL) {
LOG.error("%s: error parsing JSON message", __FUNCTION__);
return false;
}
// Check if the result contains an error
if (checkErrorMessage(root, errorCode, errorMessage)) {
cJSON* error = cJSON_GetObjectItem(root, "error");
std::vector<std::string> params = getParameters(error);
if (params.size() > 0) {
// The first parameter is the error message
serverErrorMsg = params[0];
}
cJSON_Delete(root);
return false;
}
if ((data = cJSON_GetObjectItem(root, "data")) == NULL) {
LOG.error("%s: error parsing JSON message: can't find \"data\" field", __FUNCTION__);
cJSON_Delete(root);
return false;
}
if ((user = cJSON_GetObjectItem(data, "user")) == NULL) {
LOG.error("%s: error parsing JSON message: can't find \"user\" field", __FUNCTION__);
cJSON_Delete(root);
return false;
}
if ((status = cJSON_GetObjectItem(user, "active")) == NULL) {
cJSON_Delete(root);
LOG.error("%s: error parsing JSON message: can't find \"status\" field", __FUNCTION__);
return false;
}
if ((userStatus = status->type) == cJSON_False) {
LOG.error("%s: user status is not active", __FUNCTION__);
cJSON_Delete(root);
return false;
}
cJSON_Delete(root);
return true;
}
// Quantization takes place here!
bool medianCut::performQuantization(const image& src,
image& dest,
channel8& mask,
palette &thePalette) const {
// parameters and const variables
const parameters& param = getParameters();
const int imageRows=src.rows(); // number of rows in src
const int imageCols=src.columns(); // number of columns in src
// resize destination containers
dest.resize(imageRows,imageCols,rgbPixel(),false,false);
mask.resize(imageRows,imageCols,ubyte(),false,false);
// Variables
int row,col; // row, column counters
int r,g,b; // red,green,blue
ivector iVec(3); // int-vector
std::list<boxInfo> theLeaves; // list of leaves (tree without root
// and nodes)
std::list<boxInfo>::iterator splitPos; // position to split
std::list<boxInfo>::iterator iter; // iterator for theLeaves
// create histogram with desired pre-quantization dimensions from src
histogram theHist(3,param.preQuant);
const float factor = param.preQuant/256.0f;
for (row = 0 ; row < imageRows ; row++) {
for (col = 0 ; col < imageCols ; col++) {
r = static_cast<int>(src.at( row,col ).getRed() * factor);
g = static_cast<int>(src.at( row,col ).getGreen() * factor);
b = static_cast<int>(src.at( row,col ).getBlue() * factor);
// insert point with quantized color
dest.at(row,col).set((r*256+128)/param.preQuant,
(g*256+128)/param.preQuant,
(b*256+128)/param.preQuant,0);
iVec[0] = r;
iVec[1] = g;
iVec[2] = b;
theHist.put(iVec);
}
}
// initialization of first box of list (the whole histogram)
boxInfo theBox(rgbPixel(0,0,0),
rgbPixel(param.preQuant-1,
param.preQuant-1,
param.preQuant-1));
computeBoxInfo(theHist,theBox);
// return, if desired number of colors smaller than colors in
// pre-quantized image
if (theBox.colors < param.numberOfColors) {
thePalette.resize(theBox.colors,rgbPixel(),false,false);
// prepare palette
int i = 0;
for (r=0;r<param.preQuant;++r) {
for (g=0;g<param.preQuant;++g) {
for (b=0;b<param.preQuant;++b) {
iVec[0] = r;
iVec[1] = g;
iVec[2] = b;
if (theHist.at(iVec) > 0) {
thePalette.at(i).set((r*256+128)/param.preQuant,
(g*256+128)/param.preQuant,
(b*256+128)/param.preQuant);
}
}
}
}
// use the palette to generate the corresponding channel
usePalette colorizer;
colorizer.apply(dest,thePalette,mask);
return true;
}
// Push first box into List
theLeaves.push_back(theBox);
// MAIN LOOP (do this until you have enough leaves (count), or no
// splittable boxes (entries))
int count, entries=1; // auxiliary variables for the main loop
for (count=1; (count<param.numberOfColors) && (entries!=0); count++) {
// find box with largest number of entries from list
entries = 0;
for (iter = theLeaves.begin() ; iter != theLeaves.end() ; iter++) {
if ( (*iter).colorFrequency > entries ) {
// Avoid choosing single colors, i.e. unsplittable boxes
if ( ((*iter).max.getRed() > (*iter).min.getRed()) ||
((*iter).max.getGreen() > (*iter).min.getGreen()) ||
((*iter).max.getBlue() > (*iter).min.getBlue()) ) {
entries = (*iter).colorFrequency;
splitPos = iter;
}
}
}
// A splittable box was found.
// The iterator "splitPos" indicates its position in the List
if (entries >0) {
// Determine next axis to split (largest variance) and box dimensions
int splitAxis; // split axis indicator
if ( ((*splitPos).var[0] >= (*splitPos).var[1]) &&
((*splitPos).var[0] >= (*splitPos).var[2]) ) {
splitAxis = 0; // red axis
}
else if ( (*splitPos).var[1] >= (*splitPos).var[2] ) {
splitAxis = 1; // green axis
}
else {
splitAxis = 2; // blue axis
}
int rMax = ((*splitPos).max.getRed());
int rMin = ((*splitPos).min.getRed());
int gMax = ((*splitPos).max.getGreen());
int gMin = ((*splitPos).min.getGreen());
int bMax = ((*splitPos).max.getBlue());
int bMin = ((*splitPos).min.getBlue());
// pass through box along the axis to split
bool found; // becomes true when split plane is found
int nrOfCols=0; // counter: number of colors of box
int prevNrOfCols=0; // forerunner of nrOfCols
rgbPixel lower1; // lower pixel from box 1
rgbPixel upper1; // upper pixel from box 1
rgbPixel lower2; // lower pixel from box 2
rgbPixel upper2; // upper pixel from box 2
switch (splitAxis) {
case 0: // red axis
nrOfCols = 0;
for (r = rMin , found = false ; (!found) && (r<=rMax) ; r++) {
prevNrOfCols = nrOfCols;
for (g = gMin ; g <= gMax ; g++) {
for (b=bMin;b<=bMax;b++) {
iVec[0] = r;
iVec[1] = g;
iVec[2] = b;
if (theHist.at(iVec) > 0.0) {
nrOfCols += static_cast<long int>(theHist.at(iVec));
}
}
}
if ( nrOfCols >= (*splitPos).colorFrequency/2 ) {
found=true;
}
}
if (fabs(prevNrOfCols -
static_cast<float>((*splitPos).colorFrequency)/2) <
fabs(nrOfCols -
static_cast<float>((*splitPos).colorFrequency)/2)) {
r--;
nrOfCols = prevNrOfCols;
}
// first box
lower1.setRed(rMin); lower1.setGreen(gMin); lower1.setBlue(bMin);
upper1.setRed(r-1); upper1.setGreen(gMax); upper1.setBlue(bMax);
// second box
lower2.setRed(r); lower2.setGreen(gMin); lower2.setBlue(bMin);
upper2.setRed(rMax); upper2.setGreen(gMax); upper2.setBlue(bMax);
break;
case 1: // g axis
nrOfCols = 0;
for (g = gMin , found = false ; (!found) && (g<=gMax) ; g++) {
prevNrOfCols = nrOfCols;
for (r = rMin ; r <= rMax ; r++) {
for (b = bMin ; b <= bMax ; b++) {
iVec[0] = r;
iVec[1] = g;
iVec[2] = b;
if (theHist.at(iVec) > 0.0) {
nrOfCols += static_cast<long int>(theHist.at(iVec));
}
}
}
if ( nrOfCols >= (*splitPos).colorFrequency/2 ) {
found=true;
}
}
if (fabs(prevNrOfCols -
static_cast<float>((*splitPos).colorFrequency)/2) <
fabs(nrOfCols -
static_cast<float>((*splitPos).colorFrequency)/2)) {
g--;
nrOfCols = prevNrOfCols;
}
// first box
lower1.setRed(rMin); lower1.setGreen(gMin); lower1.setBlue(bMin);
upper1.setRed(rMax); upper1.setGreen(g-1); upper1.setBlue(bMax);
// second box
lower2.setRed(rMin); lower2.setGreen(g); lower2.setBlue(bMin);
upper2.setRed(rMax); upper2.setGreen(gMax); upper2.setBlue(bMax);
break;
case 2: // b axis
nrOfCols = 0;
for (b = bMin , found = false ; (!found) && (b<=bMax) ; b++) {
prevNrOfCols = nrOfCols;
for (r = rMin ; r <= rMax ; r++) {
for (g = gMin ; g <= gMax ; g++) {
iVec[0] = r;
iVec[1] = g;
iVec[2] = b;
if (theHist.at(iVec) > 0.0) {
nrOfCols += static_cast<long int>(theHist.at(iVec));
}
}
}
if ( nrOfCols >= (*splitPos).colorFrequency/2 ) {
found=true;
}
}
if (fabs(prevNrOfCols -
static_cast<float>((*splitPos).colorFrequency)/2) <
fabs(nrOfCols -
static_cast<float>((*splitPos).colorFrequency)/2)) {
b--;
nrOfCols = prevNrOfCols;
}
// first box
lower1.setRed(rMin); lower1.setGreen(gMin); lower1.setBlue(bMin);
upper1.setRed(rMax); upper1.setGreen(gMax); upper1.setBlue(b-1);
// second box
lower2.setRed(rMin); lower2.setGreen(gMin); lower2.setBlue(b);
upper2.setRed(rMax); upper2.setGreen(gMax); upper2.setBlue(bMax);
break;
default:
break;
} // end of switch
// compute box info of new boxes and
// append both at the end of list
theBox.min = lower1;
theBox.max = upper1;
computeBoxInfo(theHist,theBox);
theLeaves.push_back(theBox);
theBox.min = lower2;
theBox.max = upper2;
computeBoxInfo(theHist,theBox);
theLeaves.push_back(theBox);
// delete splited box from list
theLeaves.erase(splitPos);
}
} // end of for (MAIN LOOP)
// compute block histogram and respective color palette
thePalette.resize(theLeaves.size());
int i;
for (iter = theLeaves.begin() , i=0 ;
iter != theLeaves.end() ;
iter++ , i++) {
// misuse histogram as a look-up-table
for (r = (*iter).min.getRed(); r <= (*iter).max.getRed(); r++) {
for (g = (*iter).min.getGreen(); g <= (*iter).max.getGreen(); g++) {
for (b = (*iter).min.getBlue(); b <= (*iter).max.getBlue(); b++) {
iVec[0] = r;
iVec[1] = g;
iVec[2] = b;
theHist.at(iVec) = i; // insert palette-index (refers to
// color in palette)
}
}
}
// create palette
r = (static_cast<int>((*iter).mean[0]*factor)*256+128)/param.preQuant;
g = (static_cast<int>((*iter).mean[1]*factor)*256+128)/param.preQuant;
b = (static_cast<int>((*iter).mean[2]*factor)*256+128)/param.preQuant;
thePalette[i].set(r,g,b,0); // insert color
}
// create new image with palette and theHist
dest.resize(imageRows,imageCols);
mask.resize(imageRows,imageCols,0,false,true);
// <= 256 colors? then also fill the mask
if (thePalette.size() <= 256) {
for (row = 0 ; row < imageRows ; row++) {
for (col = 0 ; col < imageCols ; col++) {
iVec[0] = static_cast<int>(src.at( row,col ).getRed() * factor);
iVec[1] = static_cast<int>(src.at( row,col ).getGreen() * factor);
iVec[2] = static_cast<int>(src.at( row,col ).getBlue() * factor);
i = static_cast<int>(theHist.at( iVec ));
dest.at(row,col) = thePalette[i];// insert point with quantized color
mask.at(row,col) = i; // insert palette index of quantized color
}
}
}
else {
for (row = 0 ; row < imageRows ; row++) {
for (col = 0 ; col < imageCols ; col++) {
iVec[0] = static_cast<int>(src.at( row,col ).getRed() * factor);
iVec[1] = static_cast<int>(src.at( row,col ).getGreen() * factor);
iVec[2] = static_cast<int>(src.at( row,col ).getBlue() * factor);
i = static_cast<int>(theHist.at( iVec ));
r = thePalette[i].getRed();
g = thePalette[i].getGreen();
b = thePalette[i].getBlue();
dest.at(row,col).set(r,g,b,0); // insert point with quantized color
}
}
}
return true;
}
int main (int argc, char **argv){
int errnum;
// alokovani pameti
errnum = allocMem();
if (errnum != EOK) {
fprintf(stderr, "%s", ecode[errnum]);
return 2;
}
// overeni parametru
errnum = getParameters(argc, argv);
if (errnum != EOK) {
fprintf(stderr, "%s", ecode[errnum]);
return 1;
}
//generovani nahodnych cisel
srand(time(NULL));
semafors->waiting = sem_open("/bayer05_waiting", O_CREAT, S_IRUSR|S_IWUSR, 1);
semafors->boarding_Serf = sem_open("/bayer05_boarding_Serf", O_CREAT, S_IRUSR|S_IWUSR, 0);
semafors->boarding_Hacker = sem_open("/bayer05_boarding_Hacker", O_CREAT, S_IRUSR|S_IWUSR, 0);
semafors->member = sem_open("/bayer05_member", O_CREAT, S_IRUSR|S_IWUSR, 0);
semafors->landing = sem_open("/bayer05_landing", O_CREAT, S_IRUSR|S_IWUSR, 0);
semafors->finish = sem_open("/bayer05_finish", O_CREAT, S_IRUSR|S_IWUSR, 0);
semafors->boating = sem_open("/bayer05_boating", O_CREAT, S_IRUSR|S_IWUSR, 0);
semafors->checkready = sem_open("/bayer05_checkready", O_CREAT, S_IRUSR|S_IWUSR, 1);
// overeni korektnosti vytvareni semaforu
if(semafors->waiting == SEM_FAILED
|| semafors->boarding_Serf == SEM_FAILED
|| semafors->boarding_Hacker == SEM_FAILED
|| semafors->member == SEM_FAILED
|| semafors->landing == SEM_FAILED
|| semafors->finish == SEM_FAILED
|| semafors->boating == SEM_FAILED
|| semafors->checkready == SEM_FAILED)
{
fprintf(stderr, "%s", ecode[ESEMAPHORE]);
errnum = clearSources();
if (errnum != EOK) {
fprintf(stderr, "%s", ecode[errnum]);
return 2;
}
return 2;
}
fileopen();
semafors->pocet = 1;
semafors->molo_Hackers = 0;
semafors->molo_Serfs = 0;
semafors->dec = 4;
semafors->end = 0;
pid_t pid, pid2, pid3;
pid = fork();
if (pid == 0)
{
for ( int i = 0 ; i < semafors->members; i++)
{
if (semafors->serfSleep != 0)
{
usleep(rand()%(semafors->serfSleep)*1000);
}
pid2 = fork();
if (pid2 == 0)
{
SerfProc(i+1);
exit(0);
}
else if (pid2 < 0)
{
errorpid(pid2);
}
}
for ( int i = 0 ; i < semafors->members; i++)
{
wait(NULL);
}
exit(0);
}
else if (pid < 0)
{
errorpid(pid);
}
else
{
pid = fork();
if(pid == 0)
{
for( int i = 0 ; i < semafors->members; i++)
{
if (semafors->hackerSleep != 0)
{
usleep(rand()%(semafors->hackerSleep)*1000);
}
pid3 = fork();
if (pid3 == 0)
{
HackerProc(i+1);
exit(0);
}
else if (pid3 < 0)
{
errorpid(pid3);
}
}
for ( int i = 0 ; i < semafors->members; i++)
{
wait(NULL);
}
exit(0);
}
else if (pid < 0)
{
errorpid(pid);
}
else
{
signal(SIGTERM, killProces);
signal(SIGINT, killProces);
wait(NULL);
wait(NULL);
// exit(0);
}
}
errnum = clearSources();
if (errnum != EOK) {
fprintf(stderr, "%s", ecode[errnum]);
return 2;
}
return 0;
}
/*
* Generic SNMP object fetcher
*
* st=1 GET
* st=2 WALK
*/
void _php3_snmp(INTERNAL_FUNCTION_PARAMETERS, int st) {
pval *a1, *a2, *a3;
struct snmp_session session, *ss;
struct snmp_pdu *pdu=NULL, *response;
struct variable_list *vars;
char *community, *hostname;
char *objid;
oid name[MAX_NAME_LEN];
int name_length;
int status, count,rootlen=0,gotroot=0;
oid root[MAX_NAME_LEN];
char buf[2048];
int keepwalking=1;
static int mib_init=0;
if (getParameters(ht, 3, &a1, &a2, &a3) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string(a1);
convert_to_string(a2);
convert_to_string(a3);
hostname=a1->value.str.val;
community=a2->value.str.val;
objid=a3->value.str.val;
if (!mib_init) {
init_mib();
mib_init=1;
}
if (st==2) { /* walk */
rootlen = MAX_NAME_LEN;
if (strlen(objid)) { /* on a walk, an empty string means top of tree - no error */
if (read_objid(objid, root, &rootlen)) {
gotroot = 1;
} else {
php3_error(E_WARNING,"Invalid object identifier: %s\n", objid);
}
}
if (gotroot == 0) {
memmove((char *)root, (char *)objid_mib, sizeof(objid_mib));
rootlen = sizeof(objid_mib) / sizeof(oid);
gotroot = 1;
}
}
memset(&session, 0, sizeof(struct snmp_session));
session.peername = hostname;
session.version = SNMP_VERSION_1;
session.community = (u_char *)community;
session.community_len = strlen((char *)community);
session.retries = SNMP_DEFAULT_RETRIES;
session.timeout = SNMP_DEFAULT_TIMEOUT;
session.authenticator = NULL;
snmp_synch_setup(&session);
ss = snmp_open(&session);
if (ss == NULL){
php3_error(E_WARNING,"Couldn't open snmp\n");
RETURN_FALSE;
}
if (st==2) {
memmove((char *)name, (char *)root, rootlen * sizeof(oid));
name_length = rootlen;
/* prepare result array */
array_init(return_value);
}
while(keepwalking) {
keepwalking=0;
if (st==1) pdu = snmp_pdu_create(GET_REQ_MSG);
else if (st==2) pdu = snmp_pdu_create(GETNEXT_REQ_MSG);
if (st==1) {
name_length = MAX_NAME_LEN;
if (!read_objid(objid, name, &name_length)) {
php3_error(E_WARNING,"Invalid object identifier: %s\n", objid);
RETURN_FALSE;
}
}
snmp_add_null_var(pdu, name, name_length);
retry:
status = snmp_synch_response(ss, pdu, &response);
if (status == STAT_SUCCESS) {
if (response->errstat == SNMP_ERR_NOERROR) {
for(vars = response->variables; vars; vars = vars->next_variable) {
if (st==2 && (vars->name_length < rootlen || memcmp(root, vars->name, rootlen * sizeof(oid))))
continue; /* not part of this subtree */
sprint_value(buf,vars->name, vars->name_length, vars);
#if 0
Debug("snmp response is: %s\n",buf);
#endif
if (st==1) {
RETVAL_STRING(buf,1);
} else if (st==2) {
/* Add to returned array */
add_next_index_string(return_value,buf,1);
if (vars->type != SNMP_ENDOFMIBVIEW && vars->type != SNMP_NOSUCHOBJECT && vars->type != SNMP_NOSUCHINSTANCE) {
memmove((char *)name, (char *)vars->name,vars->name_length * sizeof(oid));
name_length = vars->name_length;
keepwalking = 1;
}
}
}
} else {
if (st!=2 || response->errstat != SNMP_ERR_NOSUCHNAME) {
php3_error(E_WARNING,"Error in packet.\nReason: %s\n", snmp_errstring(response->errstat));
if (response->errstat == SNMP_ERR_NOSUCHNAME) {
for(count=1, vars = response->variables; vars && count != response->errindex;
vars = vars->next_variable, count++);
if (vars) sprint_objid(buf,vars->name, vars->name_length);
php3_error(E_WARNING,"This name does not exist: %s\n",buf);
}
if (st==1) {
if ((pdu = snmp_fix_pdu(response, GET_REQ_MSG)) != NULL) goto retry;
} else if (st==2) {
if ((pdu = snmp_fix_pdu(response, GETNEXT_REQ_MSG)) != NULL) goto retry;
}
RETURN_FALSE;
}
}
} else if (status == STAT_TIMEOUT) {
php3_error(E_WARNING,"No Response from %s\n", hostname);
RETURN_FALSE;
} else { /* status == STAT_ERROR */
php3_error(E_WARNING,"An error occurred, Quitting\n");
RETURN_FALSE;
}
if (response) snmp_free_pdu(response);
} /* keepwalking */
snmp_close(ss);
}
int SynthEngine::saveProgram(char *filename) {
FILE *fh;
int size;
void *parameters;
if (!(fh = fopen(filename, "wb")))
return 1;
parameters = getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = oscillators[0]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = oscillators[1]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = envelopes[0]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = envelopes[1]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = filters[0]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = filters[1]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = lfos[0]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = lfos[1]->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
parameters = echo->getParameters(&size);
fwrite(&size, sizeof(size), 1, fh);
fwrite(parameters, size, 1, fh);
free(parameters);
fwrite(&arpMode, sizeof(arpMode), 1, fh);
fwrite(&arpSpeed, sizeof(arpSpeed), 1, fh);
fwrite(&arpOctaveMax, sizeof(arpOctaveMax), 1, fh);
fwrite(&oscBase[0], sizeof(oscBase), 1, fh);
fwrite(¬e[0], sizeof(note), 1, fh);
fclose(fh);
return 0;
}
void processAudio(AudioBuffer &buffer) {
float *in1;
float *in2;
float *out1;
float *out2;
float a, b, c, d, g, l=fb3, m, h, s, sl=slev;
float f1i=fi1, f1o=fo1, f2i=fi2, f2o=fo2, b1=fb1, b2=fb2;
float g1, d1=driv1, t1=trim1;
float g2, d2=driv2, t2=trim2;
float g3, d3=driv3, t3=trim3;
int v=valve;
int sampleFrames = buffer.getSize();
if (buffer.getChannels() < 2) { // Mono check
in1 = buffer.getSamples(0); // L
in2 = buffer.getSamples(0); // R
out1 = buffer.getSamples(0); // L
out2 = buffer.getSamples(0); // R
} else {
in1 = buffer.getSamples(0); // L
in2 = buffer.getSamples(1); // R
out1 = buffer.getSamples(0); // L
out2 = buffer.getSamples(1); // R
}
getParameters();
--in1;
--in2;
--out1;
--out2;
while(--sampleFrames >= 0)
{
a = *++in1;
b = *++in2; //process from here...
s = (a - b) * sl; //keep stereo component for later
a += (float)(b + 0.00002); //dope filter at low level
b2 = (f2i * a) + (f2o * b2); //crossovers
b1 = (f1i * b2) + (f1o * b1);
l = (f1i * b1) + (f1o * l);
m=b2-l;
h=a-b2;
g = (l>0)? l : -l;
g = (float)(1.0 / (1.0 + d1 * g) ); //distort
g1=g;
g = (m>0)? m : -m;
g = (float)(1.0 / (1.0 + d2 * g) );
g2=g;
g = (h>0)? h : -h;
g = (float)(1.0 / (1.0 + d3 * g) );
g3=g;
if(v) {
if(l>0)g1=1.0;
if(m>0)g2=1.0;
if(h>0)g3=1.0;
}
a = (l*g1*t1) + (m*g2*t2) + (h*g3*t3);
c = a + s; // output
d = a - s;
*++out1 = c * (mainGain * 2.0);
*++out2 = d * (mainGain * 2.0);
}
fb1=b1;
fb2=b2, fb3=l;
}
void
RemotePluginServer::dispatchControlEvents()
{
RemotePluginOpcode opcode = RemotePluginNoOpcode;
static float *parameterBuffer = 0;
tryRead(m_controlRequestFd, &opcode, sizeof(RemotePluginOpcode));
switch (opcode) {
case RemotePluginGetVersion:
writeFloat(m_controlResponseFd, getVersion());
break;
case RemotePluginGetName:
writeString(m_controlResponseFd, getName());
break;
case RemotePluginGetMaker:
writeString(m_controlResponseFd, getMaker());
break;
case RemotePluginTerminate:
terminate();
break;
case RemotePluginGetInputCount:
m_numInputs = getInputCount();
writeInt(m_controlResponseFd, m_numInputs);
break;
case RemotePluginGetOutputCount:
m_numOutputs = getOutputCount();
writeInt(m_controlResponseFd, m_numOutputs);
break;
case RemotePluginGetParameterCount:
writeInt(m_controlResponseFd, getParameterCount());
break;
case RemotePluginGetParameterName:
writeString(m_controlResponseFd, getParameterName(readInt(m_controlRequestFd)));
break;
case RemotePluginGetParameter:
writeFloat(m_controlResponseFd, getParameter(readInt(m_controlRequestFd)));
break;
case RemotePluginGetParameterDefault:
writeFloat(m_controlResponseFd, getParameterDefault(readInt(m_controlRequestFd)));
break;
case RemotePluginGetParameters:
{
if (!parameterBuffer) {
parameterBuffer = new float[getParameterCount()];
}
int p0 = readInt(m_controlRequestFd);
int pn = readInt(m_controlRequestFd);
getParameters(p0, pn, parameterBuffer);
tryWrite(m_controlResponseFd, parameterBuffer, (pn - p0 + 1) * sizeof(float));
break;
}
case RemotePluginHasMIDIInput:
{
bool m = hasMIDIInput();
tryWrite(m_controlResponseFd, &m, sizeof(bool));
break;
}
case RemotePluginGetProgramCount:
writeInt(m_controlResponseFd, getProgramCount());
break;
case RemotePluginGetProgramName:
writeString(m_controlResponseFd, getProgramName(readInt(m_controlRequestFd)));
break;
case RemotePluginIsReady:
{
if (!m_shm) sizeShm();
bool b(isReady());
std::cerr << "isReady: returning " << b << std::endl;
tryWrite(m_controlResponseFd, &b, sizeof(bool));
}
case RemotePluginSetDebugLevel:
{
RemotePluginDebugLevel newLevel = m_debugLevel;
tryRead(m_controlRequestFd, &newLevel, sizeof(RemotePluginDebugLevel));
setDebugLevel(newLevel);
m_debugLevel = newLevel;
break;
}
case RemotePluginWarn:
{
bool b = warn(readString(m_controlRequestFd));
tryWrite(m_controlResponseFd, &b, sizeof(bool));
break;
}
case RemotePluginShowGUI:
{
showGUI(readString(m_controlRequestFd));
break;
}
case RemotePluginHideGUI:
{
hideGUI();
break;
}
//Deryabin Andrew: vst chunks support
case RemotePluginGetVSTChunk:
{
std::vector<char> chunk = getVSTChunk();
writeRaw(m_controlResponseFd, chunk);
break;
}
case RemotePluginSetVSTChunk:
{
std::vector<char> chunk = readRaw(m_controlRequestFd);
setVSTChunk(chunk);
break;
}
//Deryabin Andrew: vst chunks support: end code
case RemotePluginNoOpcode:
break;
case RemotePluginReset:
reset();
break;
default:
std::cerr << "WARNING: RemotePluginServer::dispatchControlEvents: unexpected opcode "
<< opcode << std::endl;
}
}
const string& AdcCommand::getParam(size_t n) const {
return getParameters().size() > n ? getParameters()[n] : Util::emptyString;
}
template<> ScriptVec3 ScriptArguments::getParameter<ScriptVec3>(unsigned int arg) const
{
RW_CHECK(getParameters().size() > arg+2, "Argument list too short to get vec3");
return glm::vec3(getParameter<float>(arg), getParameter<float>(arg+1), getParameter<float>(arg+2));
}
bool brightRGB::getMedian(const image& img,dvector& dest) const{
// image empty?
if (img.empty()) {
setStatusString("image empty");
dest.resize(0);
return false;
}
const rgbPixel transColor = getParameters().transColor;
dest.resize(3);
ivector hist0(256,0);
ivector hist1(256,0);
ivector hist2(256,0);
image::const_iterator it = img.begin();
if(getParameters().transparent) {
while(it != img.end()) {
if(*it != transColor) {
++hist0.at((*it).getRed());
++hist1.at((*it).getGreen());
++hist2.at((*it).getBlue());
}
it++;
}
const int counterHalf = hist0.sumOfElements()/2;
// check for complete image transparent
if (counterHalf==0) {
setStatusString("only transparent pixels");
dest.resize(0);
return false;
}
int i,s;
i=-1,s=0;
while(++i<256 && s<counterHalf) {
s += hist0.at(i);
}
dest.at(0) = i-1;
i=-1,s=0;
while(++i<256 && s<counterHalf) {
s += hist1.at(i);
}
dest.at(1) = i-1;
i=-1,s=0;
while(++i<256 && s<counterHalf) {
s += hist2.at(i);
}
dest.at(2) = i-1;
} else { // no transparent color
while(it != img.end()) {
++hist0.at((*it).getRed());
++hist1.at((*it).getGreen());
++hist2.at((*it).getBlue());
it++;
}
const int counterHalf = img.columns()*img.rows()/2;
int i,s;
i=-1,s=0;
while(++i<256 && s<counterHalf) {
s += hist0.at(i);
}
dest.at(0) = i-1;
i=-1,s=0;
while(++i<256 && s<counterHalf) {
s += hist1.at(i);
}
dest.at(1) = i-1;
i=-1,s=0;
while(++i<256 && s<counterHalf) {
s += hist2.at(i);
}
dest.at(2) = i-1;
}
// normalize to 0..1
dest.divide(255);
return true;
};
template<> ScriptInt& ScriptArguments::getParameterRef<ScriptInt>(unsigned int arg) const
{
return *reinterpret_cast<ScriptInt*>(getParameters().at(arg).handleValue());
}
bool cwagmSegmentationEvaluation::chromosomeToPhenotype(
const chromosome& genotype,
functor::parameters& phenotype) const {
const parameters& par = getParameters();
cwagmSegmentation::parameters* phen =
dynamic_cast<cwagmSegmentation::parameters*>(&phenotype);
if (isNull(phen)) {
return false;
}
int pos=0;
int ires,theMin,theMax;
double dres;
// median kernel size
pos = binToInt(genotype,pos,bits::MedianKernel,
(par.minValues.medianParam.kernelSize-1)/2,
(par.maxValues.medianParam.kernelSize-1)/2,ires);
phen->medianParam.kernelSize = (ires*2+1);
// color splitter
pos = binToInt(genotype,pos,bits::ColorSplitter,0,7,ires);
if (par.minValues.colorSplitter == par.maxValues.colorSplitter) {
phen->colorSplitter = par.minValues.colorSplitter;
} else {
if (par.minValues.colorSplitter.find("XYZ") != std::string::npos){
theMin=1;
} else if (par.minValues.colorSplitter.find("xyY") != std::string::npos){
theMin=2;
} else if (par.minValues.colorSplitter.find("Luv") != std::string::npos){
theMin=3;
} else if (par.minValues.colorSplitter.find("rgI") != std::string::npos){
theMin=4;
} else if (par.minValues.colorSplitter.find("YUV") != std::string::npos){
theMin=5;
} else if (par.minValues.colorSplitter.find("YIQ") != std::string::npos){
theMin=6;
} else if (par.minValues.colorSplitter.find("OCP") != std::string::npos){
theMin=7;
} else { // (par.minValues.colorSplitter.find("RGB")!=std::string::npos)
theMin=0; // RGB
}
if (par.maxValues.colorSplitter.find("XYZ") != std::string::npos){
theMax=1;
} else if (par.maxValues.colorSplitter.find("xyY") != std::string::npos){
theMax=2;
} else if (par.maxValues.colorSplitter.find("Luv") != std::string::npos){
theMax=3;
} else if (par.maxValues.colorSplitter.find("rgI") != std::string::npos){
theMax=4;
} else if (par.maxValues.colorSplitter.find("YUV") != std::string::npos){
theMax=5;
} else if (par.maxValues.colorSplitter.find("YIQ") != std::string::npos){
theMax=6;
} else if (par.maxValues.colorSplitter.find("OCP") != std::string::npos){
theMax=7;
} else { // (par.maxValues.colorSplitter.find("RGB")!=std::string::npos)
theMax=0; // RGB
}
ires = max(theMin,min(theMax,ires));
switch (ires) {
case 0:
phen->colorSplitter = "lti::splitImageToRGB";
break;
case 1:
phen->colorSplitter = "lti::splitImageToXYZ";
break;
case 2:
phen->colorSplitter = "lti::splitImageToxyY";
break;
case 3:
phen->colorSplitter = "lti::splitImageToLuv";
break;
case 4:
phen->colorSplitter = "lti::splitImageTorgI";
break;
case 5:
phen->colorSplitter = "lti::splitImageToYUV";
break;
case 6:
phen->colorSplitter = "lti::splitImageToYIQ";
break;
case 7:
phen->colorSplitter = "lti::splitImageToOCP";
break;
default:
phen->colorSplitter = "lti::splitImageToXYZ";
break;
}
}
// gradient kernel type
pos = binToInt(genotype,pos,bits::GradientType,0,7,ires);
if (par.minValues.colorContrastParam.kernelType ==
par.maxValues.colorContrastParam.kernelType) {
phen->colorContrastParam.kernelType =
par.minValues.colorContrastParam.kernelType;
} else {
theMin = static_cast<int>(par.minValues.colorContrastParam.kernelType);
theMax = static_cast<int>(par.maxValues.colorContrastParam.kernelType);
minmax(theMin,theMax);
ires = max(theMin,min(theMax,ires));
phen->colorContrastParam.kernelType =
static_cast<gradientFunctor::parameters::eKernelType>(ires);
}
// gradient contrast format
pos = binToInt(genotype,pos,bits::ContrastFormat,0,3,ires);
if (par.minValues.colorContrastParam.contrastFormat ==
par.maxValues.colorContrastParam.contrastFormat) {
phen->colorContrastParam.contrastFormat =
par.minValues.colorContrastParam.contrastFormat;
} else {
theMin=static_cast<int>(par.minValues.colorContrastParam.contrastFormat);
theMax=static_cast<int>(par.maxValues.colorContrastParam.contrastFormat);
minmax(theMin,theMax);
ires = max(theMin,min(theMax,ires));
phen->colorContrastParam.contrastFormat =
static_cast<colorContrastGradient::parameters::eContrastFormat>(ires);
}
// watershed configuration
// neighborhood
pos = binToInt(genotype,pos,bits::WatershedNeighborhood,
(par.minValues.watershedParam.neighborhood8) ? 1 : 0,
(par.maxValues.watershedParam.neighborhood8) ? 1 : 0,
ires);
phen->watershedParam.neighborhood8 = (ires != 0);
// WatershedThreshold
pos = binToInt(genotype,pos,bits::WatershedThreshold,
par.minValues.watershedParam.threshold,
par.maxValues.watershedParam.threshold,ires);
phen->watershedParam.threshold = static_cast<ubyte>(ires);
// minProbForWatershedThreshold
pos = binToDouble(genotype,pos,bits::WatershedMinProbThreshold,
par.minValues.minProbForWatershedThreshold,
par.maxValues.minProbForWatershedThreshold,dres);
phen->minProbForWatershedThreshold = static_cast<float>(dres);
// harisRegionMergeParam.mergeThreshold
pos = binToDouble(genotype,pos,bits::WatershedHarisMerge,
par.minValues.harisRegionMergeParam.mergeThreshold,
par.maxValues.harisRegionMergeParam.mergeThreshold,dres);
phen->harisRegionMergeParam.mergeThreshold = static_cast<float>(dres);
// harisRegionMergeParam.mergeMode
pos = binToInt(genotype,pos,bits::WatershedHarisMergeMode,
static_cast<int>(par.minValues.harisRegionMergeParam.mergeMode),
static_cast<int>(par.maxValues.harisRegionMergeParam.mergeMode),
ires);
phen->harisRegionMergeParam.mergeMode =
static_cast<regionGraphColorHaris::parameters::eMergeMode>(ires);
// harisRegionMergeParam.minRegionNumber
pos = binToDouble(genotype,pos,bits::WatershedHarisMinNumRegions,
par.minValues.harisRegionMergeParam.minRegionNumber,
par.maxValues.harisRegionMergeParam.minRegionNumber,
dres);
phen->harisRegionMergeParam.minRegionNumber = iround(dres);
// check in debug modus that everything is there!
assert(pos == bits::total());
return true;
}
template<> ScriptInt ScriptArguments::getParameter<ScriptInt>(unsigned int arg) const
{
return getParameters().at(arg).integerValue();
}
bool cwagmSegmentationEvaluation::phenotypeToChromosome(
const functor::parameters& phenotype,
chromosome& genotype) const {
genotype.resize(bits::total());
const parameters& par = getParameters();
const cwagmSegmentation::parameters* phen =
dynamic_cast<const cwagmSegmentation::parameters*>(&phenotype);
if (isNull(phen)) {
return false;
}
int pos=0;
int ires;
// median kernel size
pos = intToBin((phen->medianParam.kernelSize-1)/2,pos,bits::MedianKernel,
(par.minValues.medianParam.kernelSize-1)/2,
(par.maxValues.medianParam.kernelSize-1)/2,
genotype);
// color splitter
if (phen->colorSplitter.find("XYZ") != std::string::npos) {
ires=1;
} else if (phen->colorSplitter.find("xyY") != std::string::npos) {
ires=2;
} else if (phen->colorSplitter.find("Luv") != std::string::npos) {
ires=3;
} else if (phen->colorSplitter.find("rgI") != std::string::npos) {
ires=4;
} else if (phen->colorSplitter.find("YUV") != std::string::npos) {
ires=5;
} else if (phen->colorSplitter.find("YIQ") != std::string::npos) {
ires=6;
} else if (phen->colorSplitter.find("OCP") != std::string::npos) {
ires=7;
} else { // (phen->colorSplitter.find("RGB")!=std::string::npos)
ires=0; // RGB
}
pos = intToBin(ires,pos,bits::ColorSplitter,0,7,genotype);
// gradient kernel type
ires = static_cast<int>(phen->colorContrastParam.kernelType);
pos = intToBin(ires,pos,bits::GradientType,0,7,genotype);
// gradient contrast format
ires = static_cast<int>(phen->colorContrastParam.contrastFormat);
pos = intToBin(ires,pos,bits::ContrastFormat,0,3,genotype);
// watershed
// neighborhood
pos = intToBin((phen->watershedParam.neighborhood8) ? 1 : 0,
pos,bits::WatershedNeighborhood,
(par.minValues.watershedParam.neighborhood8) ? 1 : 0,
(par.maxValues.watershedParam.neighborhood8) ? 1 : 0,
genotype);
// WatershedThreshold
pos = intToBin(phen->watershedParam.threshold,
pos,bits::WatershedThreshold,
par.minValues.watershedParam.threshold,
par.maxValues.watershedParam.threshold,genotype);
// minProbForWatershedThreshold
pos = doubleToBin(phen->minProbForWatershedThreshold,
pos,bits::WatershedMinProbThreshold,
par.minValues.minProbForWatershedThreshold,
par.maxValues.minProbForWatershedThreshold,genotype);
// harisRegionMergeParam.mergeThreshold
pos = doubleToBin(phen->harisRegionMergeParam.mergeThreshold,
pos,bits::WatershedHarisMerge,
par.minValues.harisRegionMergeParam.mergeThreshold,
par.maxValues.harisRegionMergeParam.mergeThreshold,
genotype);
// neighborhood
pos = intToBin(static_cast<int>(phen->harisRegionMergeParam.mergeMode),
pos,bits::WatershedHarisMergeMode,
static_cast<int>(par.minValues.harisRegionMergeParam.mergeMode),
static_cast<int>(par.maxValues.harisRegionMergeParam.mergeMode),
genotype);
// harisRegionMergeParam.minRegionNumber
pos = doubleToBin(double(phen->harisRegionMergeParam.minRegionNumber),
pos,bits::WatershedHarisMinNumRegions,
par.minValues.harisRegionMergeParam.minRegionNumber,
par.maxValues.harisRegionMergeParam.minRegionNumber,
genotype);
assert (pos == bits::total());
return true;
}
void IsobaricQuantifier::updateMembers_()
{
isotope_correction_enabled_ = getParameters().getValue("isotope_correction") == "true";
normalization_enabled_ = getParameters().getValue("normalization") == "true";
}
functor::parameters* cwagmSegmentationEvaluation::getInstanceOfParam() const{
return getParameters().minValues.clone();
}
int main(int argc,char **argv) //for warp DTI
{//warp DT, this is the real Main()
int xx,yy,zz;
struct DTensor * nDTvol=NULL;
getParameters(argc, argv);
cout << "Step 1. loading Diffusion Tensor...." << endl << endl;
// rv volDT= new DTVolume(DTfile,256,256,resX,resY,resZ); //1,1,1);
volDT= new DTVolume(DTfile,dimX,dimX,resX,resY,resZ); //1,1,1);
//,256,256,0.9766,0.9766,3.0);
volDT->getDimXYZ(xx, yy, zz);
if (flipZ) volDT->flipZComponent();
//volDT->printTensors();
//return 0;
//exit(0);
cout << endl <<"Step 2. loading the warping vector field.... \n";
cout << " resolution of the volume not important" << endl;
vm=new VoxMap("N/A",fforwardVF, YES, xx, yy, zz,resX,resY,resZ);
//1,1,1);
//, resX,resY,resZ); //0.9766, 0.9766, 3.0);
cout << endl <<"Step 3. loading the Primary Direction (PD) vectors .... \n";
if (fPD[0] != '\0')
PD=new VoxMap("N/A",fPD, YES,xx, yy, zz);
else {
cout << " PD file not supplied. "<<endl;
cout << " This version does not support this feature. I will now exit."<<endl;
exit(0);
}
if (fPD2[0] != '\0'){
cout << endl <<" loading the 2nd Primary Direction (PD2) vectors .... \n";
PD2=new VoxMap("N/A",fPD2, YES,xx, yy, zz);
}else {
cout << " PD2 file not supplied. "<<endl;
PD2 = NULL;
}
cout << endl << "Step 4. create matrix volume mVolume: use SVD; and optimize the original DTI \n";
mSVD = new mVolume(xx,yy,zz);
//===============
optDTI= new DTVolume; // create space for optimized DTI volume
optDTI->newVolume(xx, yy, zz,resX,resY,resZ); // to be used in agentForGetTransMatrix()
// m_set_procs(CPUs);
// int cn= m_get_numprocs();
int cn=1;
// cout <<" Main(): cpu to be used = "<<cn<<endl;
// m_fork(agentForGetTransMatrix); //compute transformation matrix
//m_kill_procs();
// reset all maratrices to be identity matrix I
mSVD->loadIdentity(); //only for experiment of no reorientation, only relocation
// needs to be removed
// optDTI->saveTensorData("optimized.d1"); //save the optimized DTI volume
//exit(0);
//================
//mSVD -> getTransMatrixOld(vm,*volDT);
//mSVD -> getTransMatrix(vm,volDT, PD);
mSVD -> getTransMatrix(vm,volDT, PD, PD2, optDTI,USE_OPTIMIZED_DT_VOLUME);
delete PD;
/***** for debugging purpose ****
Ellipsoid E;
mSVD->weightedShapeAt(120, 17, 62,vm, volDT,E,n);
mSVD->weightedShapeAt(126, 74, 44,vm, volDT,E,n);
mSVD->weightedShapeAt(123, 50, 46,vm, volDT,E,n);
cout <<" ################"<<endl<<endl;
mSVD->weightedShapeAt(125, 122, 36,vm, volDT,E,n);
mSVD->weightedShapeAt(125, 172, 66,vm, volDT,E,n);
***** for debugging purpose ****/
//delete warp;
cout << endl << "Step 5. warp the (optimized) DT volume from original->atlas" << endl << endl;
//****//
if (USE_OPTIMIZED_DT_VOLUME){ //use optimized DT volume to replace the original noisy one
delete volDT; //delete the old noise DT volume
// load in the new optimized DT generated in calculating the reorientation matrix
volDT= optDTI;
//new DTVolume("optimized.d",256,256,resX,resY,resZ); //1,1,1);
//,256,256,0.9766,0.9766,3.0);
if (flipZ) volDT->flipZComponent();
} else{
delete optDTI;
}
// mSVD->loadIdentity();
//DTVolume *volDT;
//getchar();
volDT->reorientTensor(mSVD);
delete mSVD;
cout << endl << "Step 6. Cast DT to grid in Atlas" << endl << endl;
//****//
nDTvol = volDT->warpTensorField(vm,destZ);
delete vm;
cout << "saving resulting DT file to <"<<outDTfile<<">...."<<endl;
//****//
//rv volDT->saveData(outDTfile, nDTvol, atlasX*atlasY*destZ);
volDT->saveData(outDTfile, nDTvol, xx*yy*destZ);
cout << "new DT volume <"<<outDTfile<<"> saved." <<endl;
//****//
delete []nDTvol;
delete volDT;
cout << endl << "program completed." << endl <<endl;
cout <<endl<< "~~~~~~~~~~~~~~~~" <<endl;
cout <<" feed back to [email protected]. Thanks" <<endl;
return 0;
}
void php3_Ora_Do_Logon(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
char *user = NULL;
char *pwd = NULL;
pval *arg1, *arg2;
oraConnection *db_conn;
list_entry *index_ptr;
char *hashed_details;
int hashed_len, len, id;
ORACLE_TLS_VARS;
if (getParameters(ht, 2, &arg1, &arg2) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string(arg1);
convert_to_string(arg2);
user = arg1->value.str.val;
pwd = arg2->value.str.val;
if (!ORACLE_GLOBAL(php3_oracle_module).allow_persistent) {
persistent = 0;
}
if (ORACLE_GLOBAL(php3_oracle_module).max_links != -1 &&
ORACLE_GLOBAL(php3_oracle_module).num_links >=
ORACLE_GLOBAL(php3_oracle_module).max_links) {
php3_error(E_WARNING, "Oracle: Too many open links (%d)",
ORACLE_GLOBAL(php3_oracle_module).num_links);
RETURN_FALSE;
}
/* the user requested a persistent connection */
if (persistent &&
ORACLE_GLOBAL(php3_oracle_module).max_persistent != -1 &&
ORACLE_GLOBAL(php3_oracle_module).num_persistent >=
ORACLE_GLOBAL(php3_oracle_module).max_persistent) {
php3_error(E_WARNING,"Oracle: Too many open persistent links (%d)",
ORACLE_GLOBAL(php3_oracle_module).num_persistent);
RETURN_FALSE;
}
len = strlen(user) + strlen(pwd) + 9;
hashed_details = emalloc(len);
if (hashed_details == NULL) {
php3_error(E_WARNING, "Out of memory");
RETURN_FALSE;
}
hashed_len = _php3_sprintf(hashed_details, "ora_%s_%s", user, pwd);
/* try to find if we already have this link in our persistent list,
* no matter if it is to be persistent or not
*/
if (_php3_hash_find(plist, hashed_details, hashed_len + 1,
(void **) &index_ptr) == FAILURE) {
/* the link is not in the persistent list */
list_entry new_index_ptr;
if (persistent)
db_conn = (oraConnection *)malloc(sizeof(oraConnection));
else
db_conn = (oraConnection *)emalloc(sizeof(oraConnection));
if (db_conn == NULL){
efree(hashed_details);
php3_error(E_WARNING, "Out of memory");
RETURN_FALSE;
}
memset((void *) db_conn,0,sizeof(oraConnection));
#if HAS_OLOG
if (olog(&db_conn->lda, db_conn->hda, user,
strlen(user), pwd, strlen(pwd), 0, -1, OCI_LM_DEF)) {
#else
if (orlon(&db_conn->lda, db_conn->hda, user,
strlen(user), pwd, strlen(pwd), 0)) {
#endif
php3_error(E_WARNING, "Unable to connect to ORACLE (%s)",
ora_error(&db_conn->lda));
/* The next line is to provide error information
* for OraError && OraErrorCode calls */
db_err_conn = *db_conn;
if (persistent)
free(db_conn);
else
efree(db_conn);
efree(hashed_details);
RETURN_FALSE;
}
db_conn->open = 1;
if (persistent){
/*new_le.type = ORACLE_GLOBAL(php3_oracle_module).le_pconn;
new_le.ptr = db_conn;*/
RETVAL_RESOURCE(php3_plist_insert(db_conn, ORACLE_GLOBAL(php3_oracle_module).le_pconn));
new_index_ptr.ptr = (void *) return_value->value.lval;
new_index_ptr.type = le_index_ptr;
if (_php3_hash_update(plist,hashed_details,hashed_len + 1,(void *) &new_index_ptr,
sizeof(list_entry),NULL) == FAILURE) {
ologof(&db_conn->lda);
free(db_conn);
efree(hashed_details);
php3_error(E_WARNING, "Can't update hashed details list");
RETURN_FALSE;
}
ORACLE_GLOBAL(php3_oracle_module).num_persistent++;
} else {
/* non persistent, simply add to list */
RETVAL_RESOURCE(php3_list_insert(db_conn, ORACLE_GLOBAL(php3_oracle_module).le_conn));
}
ORACLE_GLOBAL(php3_oracle_module).num_links++;
} else {
int type;
/* the link is already in the persistent list */
if (index_ptr->type != le_index_ptr) {
efree(hashed_details);
php3_error(E_WARNING, "Oops, something went completly wrong");
RETURN_FALSE;
}
id = (int) index_ptr->ptr;
db_conn = (oraConnection *)php3_plist_find(id, &type);
if (db_conn && (type == ORACLE_GLOBAL(php3_oracle_module).le_conn ||
type == ORACLE_GLOBAL(php3_oracle_module).le_pconn)){
if(!_ora_ping(db_conn)) {
/* XXX Reinitialize lda, hda ? */
#if HAS_OLOG
if(olog(&db_conn->lda, db_conn->hda, user,
strlen(user), pwd, strlen(pwd), 0, -1, OCI_LM_DEF)) {
#else
if(orlon(&db_conn->lda, db_conn->hda, user,
strlen(user), pwd, strlen(pwd), 0)) {
#endif
/* The next line is to provide error information
* for OraError && OraErrorCode calls */
db_err_conn = *db_conn;
php3_error(E_WARNING, "Unable to reconnect to ORACLE (%s)",
ora_error(&db_conn->lda));
/* Delete list entry for this connection */
php3_plist_delete(id);
/* Delete hashed list entry for this dead connection */
_php3_hash_del(plist, hashed_details, hashed_len);
efree(hashed_details);
RETURN_FALSE;
}
}
RETVAL_RESOURCE(id);
}
}
_php3_hash_add(ORACLE_GLOBAL(php3_oracle_module).conns,
(void*)&db_conn,
sizeof(void*),
(void*)&db_conn,
sizeof(void*),
NULL);
efree(hashed_details);
}
/* {{{ proto int ora_logoff(int connection)
Close an Oracle connection */
void php3_Ora_Logoff(INTERNAL_FUNCTION_PARAMETERS)
{ /* conn_index */
int type, ind;
oraConnection *conn;
pval *arg;
ORACLE_TLS_VARS;
if (getParameters(ht, 1, &arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_long(arg);
ind = (int)arg->value.lval;
conn = (oraConnection *)php3_list_find(ind, &type);
if (!conn || (type != ORACLE_GLOBAL(php3_oracle_module).le_conn &&
type != ORACLE_GLOBAL(php3_oracle_module).le_pconn)) {
return;
}
php3_list_delete(ind);
}
