void ParameterList::append(const QString &pName)
{
append(Parameter(pName, QVariant()));
}
//-----------------------------------------------------------------------
ParameterPtr ParameterFactory::createOutColor(int index)
{
return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT4, "oColor_" + StringConverter::toString(index),
Parameter::SPS_COLOR, index,
index == 0 ? Parameter::SPC_COLOR_DIFFUSE : Parameter::SPC_COLOR_SPECULAR));
}
AD<Base>& AD<Base>::operator -= (const AD<Base> &right)
{ ADTape<Base> *tape = AD<Base>::tape_ptr();
size_t tape_id = 0;
if( tape != CPPAD_NULL )
tape_id = tape->id_;
// id_ setting for parameters cannot match 0
bool var_left = id_ == tape_id;
bool var_right = right.id_ == tape_id;
CPPAD_ASSERT_KNOWN(
Parameter(*this) || var_left ,
"-=: left operand is a variable for a different thread"
);
CPPAD_ASSERT_KNOWN(
Parameter(right) || var_right ,
"-=: right operand is a variable for a different thread"
);
Base left;
left = value_;
value_ -= right.value_;
if( var_left )
{ if( var_right )
{ // this = variable - variable
CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
// put operand addresses in tape
tape->Rec_.PutArg(taddr_, right.taddr_);
// put operator in the tape
taddr_ = tape->Rec_.PutOp(SubvvOp);
// make this a variable
CPPAD_ASSERT_UNKNOWN( id_ == tape_id );
}
else if( IdenticalZero( right.value_ ) )
{ // this = variable - 0
}
else
{ // this = variable - parameter
CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
// put operand addresses in tape
addr_t p = tape->Rec_.PutPar(right.value_);
tape->Rec_.PutArg(taddr_, p);
// put operator in the tape
taddr_ = tape->Rec_.PutOp(SubvpOp);
// make this a variable
CPPAD_ASSERT_UNKNOWN( id_ == tape_id );
}
}
else if( var_right )
{ // this = parameter - variable
CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
// put operand addresses in tape
addr_t p = tape->Rec_.PutPar(left);
tape->Rec_.PutArg(p, right.taddr_);
// put operator in the tape
taddr_ = tape->Rec_.PutOp(SubpvOp);
// make this a variable
id_ = tape_id;
}
return *this;
}
//-----------------------------------------------------------------------
ParameterPtr ParameterFactory::createOutPosition(int index)
{
return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT4, "oPos_" + StringConverter::toString(index),
Parameter::SPS_POSITION, index,
Parameter::SPC_POSITION_PROJECTIVE_SPACE));
}
//-----------------------------------------------------------------------
ParameterPtr ParameterFactory::createOutBiNormal(int index)
{
return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT3, "oBiNormal_" + StringConverter::toString(index),
Parameter::SPS_BINORMAL, index,
Parameter::SPC_BINORMAL));
}
// **************************************************************************
// Function: Preflight
// Purpose: Checks parameters for availability and consistency with
// input signal properties; requests minimally needed properties for
// the output signal; checks whether resources are available.
// Parameters: Input and output signal properties pointers.
// Returns: N/A
// **************************************************************************
void DataGlove5DTUFilter::Preflight( const SignalProperties& Input,
SignalProperties& Output ) const
{
HINSTANCE hinstLib = NULL;
FDOPEN fdOpenCall = NULL;
FDCLOSE fdCloseCall = NULL;
FDSCANUSB fdScanUSBCall = NULL;
FDGETGLOVETYPE fdGetGloveTypeCall = NULL;
FDGETGLOVEHAND fdGetGloveHandCall = NULL;
FDGETNUMSENSORS fdGetNumSensorsCall = NULL;
FDGETSENSORRAWALL fdGetSensorRawAllCall = NULL;
FDGETSENSORRAW fdGetSensorRawCall = NULL;
fdGlove *pGlove = NULL;
int ret = -1;
char *szPort = NULL;
char szPortToOpen[6];
int glovetype = FD_GLOVENONE;
int glovehand = -1;
int glovesensors = -1;
bool datagloveenable = false;
datagloveenable = ( ( int )Parameter( "DataGloveEnable" ) != 0 );
if (!datagloveenable) {
hinstLib = NULL;
hinstLib = LoadLibrary(TEXT("fglove.dll"));
if (hinstLib != NULL) {
fdOpenCall = (FDOPEN) GetProcAddress(hinstLib, TEXT("?fdOpen@@YAPAUfdGlove@@PAD@Z"));
fdCloseCall = (FDCLOSE) GetProcAddress(hinstLib, TEXT("?fdClose@@YAHPAUfdGlove@@@Z"));
fdScanUSBCall = (FDSCANUSB) GetProcAddress(hinstLib, TEXT("?fdScanUSB@@YAHPAGAAH@Z"));
fdGetGloveTypeCall = (FDGETGLOVETYPE) GetProcAddress(hinstLib, TEXT("?fdGetGloveType@@YAHPAUfdGlove@@@Z"));
fdGetGloveHandCall = (FDGETGLOVEHAND) GetProcAddress(hinstLib, TEXT("?fdGetGloveHand@@YAHPAUfdGlove@@@Z"));
fdGetNumSensorsCall = (FDGETNUMSENSORS) GetProcAddress(hinstLib, TEXT("?fdGetNumSensors@@YAHPAUfdGlove@@@Z"));
fdGetSensorRawAllCall = (FDGETSENSORRAWALL) GetProcAddress(hinstLib, TEXT("?fdGetSensorRawAll@@YAXPAUfdGlove@@PAG@Z"));
fdGetSensorRawCall = (FDGETSENSORRAW) GetProcAddress(hinstLib, TEXT("?fdGetSensorRaw@@YAGPAUfdGlove@@H@Z"));
if (fdOpenCall != NULL && fdCloseCall != NULL && fdScanUSBCall != NULL ||
fdGetGloveTypeCall != NULL && fdGetGloveHandCall != NULL && fdGetNumSensorsCall != NULL ||
fdGetSensorRawAllCall != NULL && fdGetSensorRawCall != NULL) {
unsigned short aPID[5];
int nNumFound = 5;
int nChosen = 0;
fdScanUSBCall(aPID,nNumFound);
if (nNumFound > 0) {
szPort = "USB";
strcpy(szPortToOpen,szPort);
sprintf(szPortToOpen,"USB%i",nChosen);
pGlove = fdOpenCall(szPortToOpen);
if (pGlove != NULL) {
glovetype = fdGetGloveTypeCall(pGlove);
glovehand = fdGetGloveHandCall(pGlove);
glovesensors = fdGetNumSensorsCall(pGlove);
int parameter_hand_type = Parameter( "DataGloveHandType" );
if (glovetype == FD_GLOVE5U_USB) {
if (parameter_hand_type == 0) {
bciout << "Left handed data glove 5DTU found on USB port." << std::endl;
} // if (parameter_hand_type == 0)
if (parameter_hand_type == 1) {
bciout << "Right handed data glove 5DTU found on USB port." << std::endl;
} // if (parameter_hand_type == 1)
bciout << "Recording form data glove 5DTU is disabled. To enable recording check DataGloveEnable in section HumanInterface Devices" << std::endl;
} // if (glovetype == FD_GLOVE5U_USB)
} // if (pGlove != NULL)
} //if (nNumFound > 0)
} // if call == NULL
} // (hinstLib != NULL)
} else {
hinstLib = NULL;
hinstLib = LoadLibrary(TEXT("fglove.dll"));
if (hinstLib == NULL) {
bcierr << "Dynamic Link Library fglove.dll for data glove 5DTU not found" << std::endl;
return;
} else {
fdOpenCall = (FDOPEN) GetProcAddress(hinstLib, TEXT("?fdOpen@@YAPAUfdGlove@@PAD@Z"));
fdCloseCall = (FDCLOSE) GetProcAddress(hinstLib, TEXT("?fdClose@@YAHPAUfdGlove@@@Z"));
fdScanUSBCall = (FDSCANUSB) GetProcAddress(hinstLib, TEXT("?fdScanUSB@@YAHPAGAAH@Z"));
fdGetGloveTypeCall = (FDGETGLOVETYPE) GetProcAddress(hinstLib, TEXT("?fdGetGloveType@@YAHPAUfdGlove@@@Z"));
fdGetGloveHandCall = (FDGETGLOVEHAND) GetProcAddress(hinstLib, TEXT("?fdGetGloveHand@@YAHPAUfdGlove@@@Z"));
fdGetNumSensorsCall = (FDGETNUMSENSORS) GetProcAddress(hinstLib, TEXT("?fdGetNumSensors@@YAHPAUfdGlove@@@Z"));
fdGetSensorRawAllCall = (FDGETSENSORRAWALL) GetProcAddress(hinstLib, TEXT("?fdGetSensorRawAll@@YAXPAUfdGlove@@PAG@Z"));
fdGetSensorRawCall = (FDGETSENSORRAW) GetProcAddress(hinstLib, TEXT("?fdGetSensorRaw@@YAGPAUfdGlove@@H@Z"));
}
if (fdOpenCall == NULL || fdCloseCall == NULL || fdScanUSBCall == NULL ||
fdGetGloveTypeCall == NULL || fdGetGloveHandCall == NULL || fdGetNumSensorsCall == NULL ||
fdGetSensorRawAllCall == NULL || fdGetSensorRawCall == NULL) {
bcierr << "Invalid version of fglove.dll" << std::endl;
return;
}
if (fdOpenCall != NULL) {
unsigned short aPID[5];
int nNumFound = 5;
int nChosen = 0;
fdScanUSBCall(aPID,nNumFound);
if (nNumFound == 0) {
bcierr << "No data glove 5DTU found on USB port" << std::endl;
return;
}
if (nNumFound > 1) {
bciout << "More than one data glove 5DTU found on USB port, will proceed with first found" << std::endl;
}
szPort = "USB";
strcpy(szPortToOpen,szPort);
sprintf(szPortToOpen,"USB%i",nChosen);
pGlove = fdOpenCall(szPortToOpen);
if (pGlove == NULL) {
bcierr << "Data Glove 5DTU is not connected to the USB port" << std::endl;
return;
} else {
glovetype = fdGetGloveTypeCall(pGlove);
glovehand = fdGetGloveHandCall(pGlove);
glovesensors = fdGetNumSensorsCall(pGlove);
if (glovetype != FD_GLOVE5U_USB) {
bcierr << "Wrong type of data glove is connected to the USB port" << std::endl;
return;
}
int parameter_hand_type = Parameter( "DataGloveHandType" );
if (glovehand == FD_HAND_LEFT && parameter_hand_type != 0) {
bcierr << "Mismatch between left handed data glove 5DTU found on USB port and right handed selected in DataGloveHandType in section HumanInterfaceDevices" << std::endl;
return;
}
if (glovehand == FD_HAND_RIGHT && parameter_hand_type != 1) {
bcierr << "Mismatch between right handed data glove 5DTU found on USB port and left handed selected in DataGloveHandType in section HumanInterfaceDevices" << std::endl;
return;
}
}
}
}
Output = Input;
}
CPPAD_INLINE_FRIEND_TEMPLATE_FUNCTION
AD<Base> CondExpOp(
enum CompareOp cop ,
const AD<Base> &left ,
const AD<Base> &right ,
const AD<Base> &if_true ,
const AD<Base> &if_false )
{
AD<Base> returnValue;
CPPAD_ASSERT_UNKNOWN( Parameter(returnValue) );
// check first case where do not need to tape
if( IdenticalPar(left) & IdenticalPar(right) )
{ switch( cop )
{
case CompareLt:
if( left.value_ < right.value_ )
returnValue = if_true;
else returnValue = if_false;
break;
case CompareLe:
if( left.value_ <= right.value_ )
returnValue = if_true;
else returnValue = if_false;
break;
case CompareEq:
if( left.value_ == right.value_ )
returnValue = if_true;
else returnValue = if_false;
break;
case CompareGe:
if( left.value_ >= right.value_ )
returnValue = if_true;
else returnValue = if_false;
break;
case CompareGt:
if( left.value_ > right.value_ )
returnValue = if_true;
else returnValue = if_false;
break;
default:
CPPAD_ASSERT_UNKNOWN(0);
returnValue = if_true;
}
return returnValue;
}
// must use CondExp incase Base is an AD type and recording
returnValue.value_ = CondExpOp(cop,
left.value_, right.value_, if_true.value_, if_false.value_);
ADTape<Base> *tape = CPPAD_NULL;
if( Variable(left) )
tape = left.tape_this();
if( Variable(right) )
tape = right.tape_this();
if( Variable(if_true) )
tape = if_true.tape_this();
if( Variable(if_false) )
tape = if_false.tape_this();
// add this operation to the tape
if( tape != CPPAD_NULL )
tape->RecordCondExp(cop,
returnValue, left, right, if_true, if_false);
return returnValue;
}
//int TARGETSEQUENCE::LoadPotentialTargets(const int targetRow, const int targetCol, const int treeRow, const int treeCol)
int TARGETSEQUENCE::LoadPotentialTargets()
{
/*shidong starts */
int targetID, parentID, displaypos, ptr, targettype;
TARGET *cur_target;
// if we already have a list of potential targets, delete this list
if (targets) delete targets;
targets=new TARGETLIST();
if(debug)fprintf(f, "Row # is %d.\n", Parameter("TargetDefinitionMatrix")->NumRows());
if(debug)fprintf(f, "ID \tType \tDisplay\tFontSizeFactor\tIconFile\n");
/* */
// parse the target definition matrix
for (int i = 0; i < Parameter("TargetDefinitionMatrix")->NumRows(); i++)
{
targetID =
AnsiString(Parameter("TargetDefinitionMatrix")(i,0).c_str()).ToInt();
cur_target = new TARGET(targetID);
cur_target->targettype = AnsiString(Parameter("TargetDefinitionMatrix")(i,1).c_str()).ToInt();
cur_target->Caption = AnsiString(Parameter("TargetDefinitionMatrix")(i,2).c_str());
cur_target->FontSizeFactor = (float)(Parameter("TargetDefinitionMatrix")(i,3));
cur_target->IconFile = AnsiString(Parameter("TargetDefinitionMatrix")(i,4).c_str());
cur_target->SoundFile = AnsiString(Parameter("TargetDefinitionMatrix")(i,5).c_str());
if(debug)fprintf(f, "%d\t", cur_target->targetID);
if(debug)fprintf(f, "%d\t", cur_target->targettype);
if(debug)fprintf(f, "%s\t", cur_target->Caption);
if(debug)fprintf(f, "%f\n", cur_target->FontSizeFactor);
if(debug)fprintf(f, "%s\n", cur_target->IconFile);
if(debug)fprintf(f, "%s\n", cur_target->SoundFile);
// VK adding for playing .wav files
if ((cur_target->SoundFile != "") && (cur_target->SoundFile != " "))
{
// perform parsing to determine sound file or TextToSpeech
if (cur_target->SoundFile.SubString(0,1) != "'" && (!cur_target->wavplayer) ) // implies .wav file
{
cur_target->wavplayer = new WavePlayer;
cur_target->wavplayer->SetFile(cur_target->SoundFile.c_str());
}
}
targets->Add(cur_target);
}//for
/*
char buf[256], line[256];
FILE *fp;
int targetID, parentID, displaypos, ptr, targettype;
TARGET *cur_target;
// if we already have a list of potential targets, delete this list
if (targets) delete targets;
targets=new TARGETLIST();
// read the target definition file
fp=fopen(targetdeffilename, "rb");
if (!fp) return(0);
while (!feof(fp))
{
fgets(line, 255, fp);
if (strlen(line) > 2)
{
ptr=0;
// first column ... target code
ptr=get_argument(ptr, buf, line, 255);
targetID=atoi(buf);
cur_target=new TARGET(targetID);
// second column ... caption
ptr=get_argument(ptr, buf, line, 255);
cur_target->Caption=AnsiString(buf).Trim();
// third column ... icon
ptr=get_argument(ptr, buf, line, 255);
cur_target->IconFile=AnsiString(buf).Trim();
targettype=TARGETTYPE_NOTYPE;
if ((targetID == TARGETID_BLANK) || (targetID == TARGETID_BACKUP) || (targetID == TARGETID_ROOT))
targettype=TARGETTYPE_CONTROL;
if ((targetID >= TARGETID_A) && (targetID <= TARGETID__))
targettype=TARGETTYPE_CHARACTER;
if ((targetID >= TARGETID_ABCDEFGHI) && (targetID <= TARGETID_YZ_))
targettype=TARGETTYPE_CHARACTERS;
cur_target->targettype=targettype;
targets->Add(cur_target);
}
}
fclose(fp);
*/
// load the tree file to go with the list of targets
//if (tree->LoadTree(treeRow, treeCol) == 0)
if (tree->LoadTree() == 0)
return(-1);
return(1);
/*shidong ends*/
}
static Parameter create(const std::string& name, const T& value)
{
return Parameter(name, value);
}
void ParameterList::append(const QString &pName, unsigned int pValue)
{
append(Parameter(pName, pValue));
}
void ParameterList::append(const QString &pName, double pValue)
{
append(Parameter(pName, pValue));
}
void ParameterList::append(const QString &pName, const QDate &pValue)
{
append(Parameter(pName, QVariant(pValue)));
}
void ParameterList::append(const QString &pName, const char *pValue)
{
append(Parameter(pName, QString(pValue)));
}
void ParameterList::append(const QString &pName, const QVariant &pValue)
{
append(Parameter(pName, pValue));
}
void AddParameter(int p)
{
mParameters.push_back(Parameter(p));
}
ShaderPlugin::ShaderPlugin()
: CFreeFrameGLPlugin()
, m_initResources(1)
{
SetMinInputs(0);
SetMaxInputs(0);
SetTimeSupported(true);
m_HostSupportsSetTime = false;
m_time = 0;
m_timeLocation = -1;
m_resolution[0] = 0;
m_resolution[1] = 0;
m_resolution[2] = 0;
m_resolutionLocation = -1;
// To FFGLize an arbitrary shader, replace shader_frag.glsl and the parameters below.
// Parameter(uniform name, minimum value, maximum value, default value)
// Standard parameters/float uniforms only for now.
m_parameters.push_back(Parameter("sVert", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("sHorizon", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("sDiag", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("sDiagAlt", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("sArms", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("sRings", 0.0, 1.0, 1.0));
m_parameters.push_back(Parameter("sSpiral", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("sSpiralAlt", 0.0, 1.0, 0.0));
m_parameters.push_back(Parameter("vertPeriod", -20.0, 10.0, 4.0));
m_parameters.push_back(Parameter("horizonPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("diagPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("diagAltPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("armPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("ringPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("spiralPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("spiralAltPeriod", -20.0, 20.0, 4.0));
m_parameters.push_back(Parameter("numVert", 0.0, 100.0, 40.0));
m_parameters.push_back(Parameter("numHorizon", 0.0, 100.0, 40.0));
m_parameters.push_back(Parameter("numDiag", 0.0, 100.0, 40.0));
m_parameters.push_back(Parameter("numDiagAlt", 0.0, 100.0, 40.0));
m_parameters.push_back(Parameter("numArms", 0.0, 24.0, 4.0));
m_parameters.push_back(Parameter("numRings", 0.0, 24.0, 4.0));
m_parameters.push_back(Parameter("numSpiral", 0.0, 24.0, 4.0));
m_parameters.push_back(Parameter("numSpiralAlt", 0.0, 24.0, 4.0));
for (int ii = 0; ii < m_parameters.size(); ii++) {
auto p = m_parameters[ii];
SetParamInfo(ii, p.Name.c_str(), FF_TYPE_STANDARD, p.Value);
}
}
bool Span::On(const Point& p, double* t)const
{
if(p != NearestPoint(p))return false;
if(t)*t = Parameter(p);
return true;
}
Core::Core(const std::string& refPath, double probaRequiered)
: _refPath(refPath), _probaRequiered(probaRequiered)
{
this->fillDataBase();
for (int i = IA1::nbControler; i <= IA1::control; i++)
{
this->_ParameterList.insert(std::pair<IA1::argumentOrder, Parameter>((IA1::argumentOrder)i, Parameter((IA1::argumentOrder)i)));
}
}
AD<Base> operator + (const AD<Base> &left , const AD<Base> &right)
{
// compute the Base part of this AD object
AD<Base> result;
result.value_ = left.value_ + right.value_;
CPPAD_ASSERT_UNKNOWN( Parameter(result) );
// check if there is a recording in progress
ADTape<Base>* tape = AD<Base>::tape_ptr();
if( tape == CPPAD_NULL )
return result;
tape_id_t tape_id = tape->id_;
// tape_id cannot match the default value for tape_id_; i.e., 0
CPPAD_ASSERT_UNKNOWN( tape_id > 0 );
bool var_left = left.tape_id_ == tape_id;
bool var_right = right.tape_id_ == tape_id;
if( var_left )
{ if( var_right )
{ // result = variable + variable
CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
// put operand addresses in tape
tape->Rec_.PutArg(left.taddr_, right.taddr_);
// put operator in the tape
result.taddr_ = tape->Rec_.PutOp(AddvvOp);
// make result a variable
result.tape_id_ = tape_id;
}
else if( IdenticalZero(right.value_) )
{ // result = variable + 0
result.make_variable(left.tape_id_, left.taddr_);
}
else
{ // result = variable + parameter
// = parameter + variable
CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
// put operand addresses in tape
addr_t p = tape->Rec_.PutPar(right.value_);
tape->Rec_.PutArg(p, left.taddr_);
// put operator in the tape
result.taddr_ = tape->Rec_.PutOp(AddpvOp);
// make result a variable
result.tape_id_ = tape_id;
}
}
else if( var_right )
{ if( IdenticalZero(left.value_) )
{ // result = 0 + variable
result.make_variable(right.tape_id_, right.taddr_);
}
else
{ // result = parameter + variable
CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
// put operand addresses in tape
addr_t p = tape->Rec_.PutPar(left.value_);
tape->Rec_.PutArg(p, right.taddr_);
// put operator in the tape
result.taddr_ = tape->Rec_.PutOp(AddpvOp);
// make result a variable
result.tape_id_ = tape_id;
}
}
return result;
}
void
mexFunction (
INT nlhs,
Matrix * plhs[],
INT nrhs,
const Matrix * prhs[]
)
{
char * opname;
OPCODE opcode;
Matrix * mat;
int status;
char * path;
int cmode;
int mode;
int cdfid;
int ndims;
int nvars;
int natts;
int recdim;
char * name;
long length;
int dimid;
nc_type datatype;
int * dim;
int varid;
long * coords;
VOIDP value;
long * start;
long * count;
int * intcount;
long * stride;
long * imap;
long recnum;
int nrecvars;
int * recvarids;
long * recsizes;
VOIDPP datap; /* pointers for record access. */
int len;
int incdf;
int invar;
int outcdf;
int outvar;
int attnum;
char * attname;
char * newname;
int fillmode;
int i;
int m;
int n;
char * p;
char buffer[MAX_BUFFER];
DOUBLE * pr;
DOUBLE addoffset;
DOUBLE scalefactor;
int autoscale; /* do auto-scaling if this flag is non-zero. */
/* Disable the NC_FATAL option from ncopts. */
if (ncopts & NC_FATAL) {
ncopts -= NC_FATAL;
}
/* Display usage if less than one input argument. */
if (nrhs < 1) {
Usage();
return;
}
/* Convert the operation name to its opcode. */
opname = Mat2Str(prhs[0]);
for (i = 0; i < strlen(opname); i++) {
opname[i] = (char) tolower((int) opname[i]);
}
p = opname;
if (strncmp(p, "nc", 2) == 0) { /* Trim away "nc". */
p += 2;
}
i = 0;
opcode = NONE;
while (ops[i].opcode != NONE) {
if (!strcmp(p, ops[i].opname)) {
opcode = ops[i].opcode;
if (ops[i].nrhs > nrhs) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few input arguments.\n");
}
else if (0 && ops[i].nlhs > nlhs) { /* Disabled. */
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few output arguments.\n");
}
break;
}
else {
i++;
}
}
if (opcode == NONE) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: No such operation.\n");
}
Free((VOIDPP) & opname);
/* Extract the cdfid by number. */
switch (opcode) {
case USAGE:
case CREATE:
case OPEN:
case TYPELEN:
case SETOPTS:
case ERR:
case PARAMETER:
break;
default:
cdfid = Scalar2Int(prhs[1]);
break;
}
/* Extract the dimid by number or name. */
switch (opcode) {
case DIMINQ:
case DIMRENAME:
if (mxIsNumeric(prhs[2])) {
dimid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
Free((VOIDPP) & name);
}
break;
default:
break;
}
/* Extract the varid by number or name. */
switch (opcode) {
case VARINQ:
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
case VARRENAME:
case VARCOPY:
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTNAME:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[2])) {
varid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
if (varid == -1) {
varid = Parameter(prhs[2]);
}
}
break;
default:
break;
}
/* Extract the attname by name or number. */
switch (opcode) {
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[3])) {
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
}
else {
attname = Mat2Str(prhs[3]);
}
break;
default:
break;
}
/* Extract the "add_offset" and "scale_factor" attributes. */
switch (opcode) {
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
addoffset = Add_Offset(cdfid, varid);
scalefactor = Scale_Factor(cdfid, varid);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
break;
default:
break;
}
/* Perform the NetCDF operation. */
switch (opcode) {
case USAGE:
Usage();
break;
case CREATE:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
cmode = Parameter(prhs[2]);
}
else {
cmode = NC_NOCLOBBER; /* Default. */
}
cdfid = nccreate(path, cmode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case OPEN:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
mode = Parameter(prhs[2]);
}
else {
mode = NC_NOWRITE; /* Default. */
}
cdfid = ncopen(path, mode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case REDEF:
status = ncredef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ENDEF:
status = ncendef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case CLOSE:
status = ncclose(cdfid);
plhs[0] = Int2Scalar(status);
break;
case INQUIRE:
status = ncinquire(cdfid, & ndims, & nvars, & natts, & recdim);
if (nlhs > 1) {
plhs[0] = Int2Scalar(ndims);
plhs[1] = Int2Scalar(nvars);
plhs[2] = Int2Scalar(natts);
plhs[3] = Int2Scalar(recdim);
plhs[4] = Int2Scalar(status);
}
else { /* Default to 1 x 5 row vector. */
plhs[0] = mxCreateFull(1, 5, REAL);
pr = mxGetPr(plhs[0]);
if (status == 0) {
pr[0] = (DOUBLE) ndims;
pr[1] = (DOUBLE) nvars;
pr[2] = (DOUBLE) natts;
pr[3] = (DOUBLE) recdim;
}
pr[4] = (DOUBLE) status;
}
break;
case SYNC:
status = ncsync(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ABORT:
status = ncabort(cdfid);
plhs[0] = Int2Scalar(status);
break;
case DIMDEF:
name = Mat2Str(prhs[2]);
length = Parameter(prhs[3]);
dimid = ncdimdef(cdfid, name, length);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMID:
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncdiminq(cdfid, dimid, name, & length);
plhs[0] = Str2Mat(name);
plhs[1] = Long2Scalar(length);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case DIMRENAME:
name = Mat2Str(prhs[3]);
status = ncdimrename(cdfid, dimid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARDEF:
name = Mat2Str(prhs[2]);
datatype = (nc_type) Parameter(prhs[3]);
ndims = Scalar2Int(prhs[4]);
if (ndims == -1) {
ndims = Count(prhs[5]);
}
dim = Mat2Int(prhs[5]);
varid = ncvardef(cdfid, name, datatype, ndims, dim);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARID:
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
plhs[0] = Str2Mat(name);
plhs[1] = Int2Scalar(datatype);
plhs[2] = Int2Scalar(ndims);
plhs[3] = Int2Mat(dim, 1, ndims);
plhs[4] = Int2Scalar(natts);
plhs[5] = Int2Scalar(status);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
break;
case VARPUT1:
coords = Mat2Long(prhs[3]);
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[4]);
}
else {
mat = prhs[4];
}
if (mat == NULL) {
mat = prhs[4];
}
pr = mxGetPr(mat);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
status = ncvarput1(cdfid, varid, coords, buffer);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARGET1:
coords = Mat2Long(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
mat = Int2Scalar(0);
pr = mxGetPr(mat);
status = ncvarget1(cdfid, varid, coords, buffer);
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARPUT:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
autoscale = (nrhs > 6 && Scalar2Int(prhs[6]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[5]);
}
else {
mat = prhs[5];
}
if (mat == NULL) {
mat = prhs[5];
}
pr = mxGetPr(mat);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarput(cdfid, varid, start, count, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & start);
Free((VOIDPP) & count);
break;
case VARGET:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvarget(cdfid, varid, start, count, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
plhs[0] = mat;
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARPUTG:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (nrhs > 7) {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[7]);
}
else {
mat = prhs[7];
}
if (mat == NULL) {
mat = prhs[7];
}
}
else {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
}
pr = mxGetPr(mat);
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
autoscale = (nrhs > 8 && Scalar2Int(prhs[8]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarputg(cdfid, varid, start, count, stride, imap, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARGETG:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
autoscale = (nrhs > 7 && Scalar2Int(prhs[7]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvargetg(cdfid, varid, start, count, stride, imap, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARRENAME:
name = Mat2Str(prhs[3]);
status = ncvarrename(cdfid, varid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[3]);
outvar = -1;
/* outvar = ncvarcopy(incdf, invar, outcdf); */
plhs[0] = Int2Scalar(outvar);
plhs[1] = Int2Scalar((outvar >= 0) ? 0 : outvar);
break;
case ATTPUT:
datatype = (nc_type) Parameter(prhs[4]);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
len = Scalar2Int(prhs[5]);
if (len == -1) {
len = Count(mat);
}
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
status = ncattput(cdfid, varid, attname, datatype, len, value);
if (value != NULL) {
Free((VOIDPP) & value);
}
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTINQ:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
plhs[0] = Int2Scalar((int) datatype);
plhs[1] = Int2Scalar(len);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTGET:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncattget(cdfid, varid, attname, value);
mat = mxCreateDoubleMatrix(1, len, mxREAL);
pr = mxGetPr(mat);
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
if (value != NULL) {
Free((VOIDPP) & value);
}
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[4] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[4]);
if (mxIsNumeric(prhs[5])) {
outvar = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[5]);
outvar = ncvarid(cdfid, name);
Free((VOIDPP) & name);
}
status = ncattcopy(incdf, invar, attname, outcdf, outvar);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTNAME:
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
plhs[0] = Str2Mat(attname);
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTRENAME:
newname = Mat2Str(prhs[4]);
status = ncattrename(cdfid, varid, attname, newname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
Free((VOIDPP) & newname);
break;
case ATTDEL:
status = ncattdel(cdfid, varid, attname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case RECPUT:
recnum = Scalar2Long(prhs[2]);
pr = mxGetPr(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if (Count(prhs[3]) < n) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
p = (char *) value;
pr = mxGetPr(prhs[3]);
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
status = ncrecput(cdfid, recnum, datap);
plhs[0] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECGET:
recnum = Scalar2Long(prhs[2]);
autoscale = (nrhs > 3 && Scalar2Int(prhs[3]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[1] = Int2Scalar(status);
break;
}
if (nrecvars == 0) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[0] = mxCreateFull(0, 0, REAL);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
if (value == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
if ((status = ncrecget(cdfid, recnum, datap)) == -1) {
plhs[1] = Int2Scalar(status);
break;
}
m = 1;
plhs[0] = mxCreateFull(m, n, REAL);
if (plhs[0] == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
pr = mxGetPr(plhs[0]);
p = (char *) value;
for (i = 0; i < nrecvars; i++) {
status = ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
if (status == -1) {
plhs[1] = Int2Scalar(status);
break;
}
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
plhs[1] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECINQ:
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status != -1) {
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
recsizes[i] /= nctypelen(datatype);
}
m = 1;
n = nrecvars;
plhs[0] = Int2Mat(recvarids, m, n);
plhs[1] = Long2Mat(recsizes, m, n);
}
plhs[2] = Int2Scalar(status);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case TYPELEN:
datatype = (nc_type) Parameter(prhs[1]);
len = nctypelen(datatype);
plhs[0] = Int2Scalar(len);
plhs[1] = Int2Scalar((len >= 0) ? 0 : 1);
break;
case SETFILL:
fillmode = Scalar2Int(prhs[1]);
status = ncsetfill(cdfid, fillmode);
plhs[0] = Int2Scalar(status);
plhs[1] = Int2Scalar(0);
break;
case SETOPTS:
plhs[0] = Int2Scalar(ncopts);
plhs[1] = Int2Scalar(0);
ncopts = Scalar2Int(prhs[1]);
break;
case ERR:
plhs[0] = Int2Scalar(ncerr);
ncerr = 0;
plhs[1] = Int2Scalar(0);
break;
case PARAMETER:
if (nrhs > 1) {
plhs[0] = Int2Scalar(Parameter(prhs[1]));
plhs[1] = Int2Scalar(0);
}
else {
i = 0;
while (strcmp(parms[i].name, "NONE") != 0) {
mexPrintf("%12d %s\n", parms[i].code, parms[i].name);
i++;
}
plhs[0] = Int2Scalar(0);
plhs[1] = Int2Scalar(-1);
}
break;
default:
break;
}
return;
}
void ADTape<Base>::RecordCondExp(
enum CompareOp cop ,
AD<Base> &returnValue ,
const AD<Base> &left ,
const AD<Base> &right ,
const AD<Base> &if_true ,
const AD<Base> &if_false )
{ size_t ind0, ind1, ind2, ind3, ind4, ind5;
size_t returnValue_taddr;
// taddr_ of this variable
CPPAD_ASSERT_UNKNOWN( NumRes(CExpOp) == 1 );
returnValue_taddr = Rec_.PutOp(CExpOp);
// ind[0] = cop
ind0 = addr_t( cop );
// ind[1] = base 2 representaion of the value
// [Var(left), Var(right), Var(if_true), Var(if_false)]
ind1 = 0;
// Make sure returnValue is in the list of variables and set its taddr
if( Parameter(returnValue) )
returnValue.make_variable(id_, returnValue_taddr );
else returnValue.taddr_ = returnValue_taddr;
// ind[2] = left address
if( Parameter(left) )
ind2 = Rec_.PutPar(left.value_);
else
{ ind1 += 1;
ind2 = left.taddr_;
}
// ind[3] = right address
if( Parameter(right) )
ind3 = Rec_.PutPar(right.value_);
else
{ ind1 += 2;
ind3 = right.taddr_;
}
// ind[4] = if_true address
if( Parameter(if_true) )
ind4 = Rec_.PutPar(if_true.value_);
else
{ ind1 += 4;
ind4 = if_true.taddr_;
}
// ind[5] = if_false address
if( Parameter(if_false) )
ind5 = Rec_.PutPar(if_false.value_);
else
{ ind1 += 8;
ind5 = if_false.taddr_;
}
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
CPPAD_ASSERT_UNKNOWN( ind1 > 0 );
Rec_.PutArg(ind0, ind1, ind2, ind3, ind4, ind5);
// check that returnValue is a dependent variable
CPPAD_ASSERT_UNKNOWN( Variable(returnValue) );
}
CmdPrescaler1()
{
address.address = kCtrlPrescaler1;
address.data = 0;
// low-frequency PWM for motors and bulbs
switch (Parameter(kParamCH1Type).get()) {
case v3_output_type::kLowPowerBulb:
case v3_output_type::kHighPowerBulb:
case v3_output_type::kMotor:
prescaler_1.prs1 = kPRSDiv4;
break;
default:
break;
}
switch (Parameter(kParamCH2Type).get()) {
case v3_output_type::kLowPowerBulb:
case v3_output_type::kHighPowerBulb:
case v3_output_type::kMotor:
prescaler_1.prs2 = kPRSDiv4;
break;
default:
break;
}
switch (Parameter(kParamCH3Type).get()) {
case v3_output_type::kLowPowerBulb:
case v3_output_type::kHighPowerBulb:
case v3_output_type::kMotor:
prescaler_1.prs3 = kPRSDiv4;
break;
default:
break;
}
switch (Parameter(kParamCH4Type).get()) {
case v3_output_type::kLowPowerBulb:
case v3_output_type::kHighPowerBulb:
case v3_output_type::kMotor:
prescaler_1.prs4 = kPRSDiv4;
break;
default:
break;
}
switch (Parameter(kParamCH5Type).get()) {
case v3_output_type::kLowPowerBulb:
case v3_output_type::kHighPowerBulb:
case v3_output_type::kMotor:
prescaler_1.prs5 = kPRSDiv4;
break;
default:
break;
}
}
//-----------------------------------------------------------------------
ParameterPtr ParameterFactory::createOutNormal(int index)
{
return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT3, "oNormal_" + StringConverter::toString(index),
Parameter::SPS_NORMAL, index,
Parameter::SPC_NORMAL_OBJECT_SPACE));
}
virtual void addToggleButton(char* label, float* zone)
{
mParameters.push_back(Parameter(kToggleButton, label, zone));
}
//-----------------------------------------------------------------------
ParameterPtr ParameterFactory::createOutTangent(int index)
{
return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT3, "oTangent_" + StringConverter::toString(index),
Parameter::SPS_TANGENT, index,
Parameter::SPC_TANGENT));
}
virtual void addCheckButton(char* label, float* zone)
{
mParameters.push_back(Parameter(kCheckButton, label, zone));
}
//-----------------------------------------------------------------------
ParameterPtr ParameterFactory::createOutTexcoord4(int index, Parameter::Content content)
{
return ParameterPtr(OGRE_NEW Parameter(GCT_FLOAT4, "oTexcoord4_" + StringConverter::toString(index),
Parameter::SPS_TEXTURE_COORDINATES, index,
content));
}
void AddParameter()
{
mParameters.push_back(Parameter());
}
/*static*/ Variable Variable::Deserialize(const Dictionary& dict, const CNTK::DeviceDescriptor& device)
{
static const vector<std::wstring> s_requiredDictionaryKeys = { typeKey, uidKey, kindKey, dataTypeKey, dynamicAxisKey, isSparseKey, needsGradientKey, shapeKey };
size_t version = ValidateDictionary<Variable>(dict, s_requiredDictionaryKeys, s_variableTypeValue, s_serializationVersion);
const auto& uid = dict[uidKey].Value<std::wstring>();
VariableKind kind = VariableKind(dict[kindKey].Value<std::size_t>());
if (kind != VariableKind::Constant &&
kind != VariableKind::Input &&
kind != VariableKind::Parameter &&
kind != VariableKind::Placeholder)
{
LogicError("Unexpected variable '%ls':'%u' (%s).",
kindKey.c_str(),
static_cast<std::underlying_type<VariableKind>::type>(kind),
GetVersionsString<Variable>(s_serializationVersion, version).c_str());
}
DataType dataType = DataType(dict[dataTypeKey].Value<std::size_t>());
if (dataType != DataType::Unknown &&
dataType != DataType::Float &&
dataType != DataType::Double)
{
LogicError("Unexpected variable '%ls':'%u' (%s).",
dataTypeKey.c_str(),
static_cast<std::underlying_type<DataType>::type>(dataType),
GetVersionsString<Variable>(s_serializationVersion, version).c_str());
}
const vector<DictionaryValue>& dictionaryValueVector = dict[dynamicAxisKey].Value<vector<DictionaryValue>>();
vector<Axis> dynamicAxis;
dynamicAxis.reserve(dictionaryValueVector.size());
for (const auto& dictionaryValue : dictionaryValueVector)
{
dynamicAxis.push_back(dictionaryValue.Value<Axis>());
}
bool isSparse = dict[isSparseKey].Value<bool>();
std::wstring name = L"";
if (dict.Contains(nameKey))
name = dict[nameKey].Value<std::wstring>();
bool needsGradient = dict[needsGradientKey].Value<bool>();
const auto& shape = dict[shapeKey].Value<NDShape>();
if (kind == VariableKind::Constant || kind == VariableKind::Parameter)
{
auto& value = dict[valueKey].Value<NDArrayView>();
// TODO: this copying here is redundant, value should be moved from the dictionary to the variable.
// Also, the correct device should be used upfront when deserializing NDArrayView.
Variable var(shape, kind, dataType, value.DeepClone(device, kind == VariableKind::Constant), needsGradient, dynamicAxis, isSparse, name, uid);
if (var.IsParameter())
return Parameter(var);
else
return Constant(var);
}
return Variable(shape, kind, dataType, nullptr, needsGradient, dynamicAxis, isSparse, name, uid);
}
// case where x and y are AD<Base> -----------------------------------------
template <class Base> AD<Base>
pow(const AD<Base> &x, const AD<Base> &y)
{ ADTape<Base> *tape = AD<Base>::tape_ptr();
bool var_x, var_y;
# ifdef NDEBUG
if( tape == CPPAD_NULL )
{ var_x = false;
var_y = false;
}
else
{
var_x = x.id_ == tape->id_;
var_y = y.id_ == tape->id_;
}
# else
var_x = Variable(x);
var_y = Variable(y);
CPPAD_ASSERT_KNOWN(
(! var_x) || x.id_ == tape->id_ ,
"pow first operand is a variable for a different thread"
);
CPPAD_ASSERT_KNOWN(
(! var_y) || y.id_ == tape->id_ ,
"pow second operand is a variable for a different thread"
);
# endif
AD<Base> result;
result.value_ = pow(x.value_, y.value_);
CPPAD_ASSERT_UNKNOWN( Parameter(result) );
if( var_x )
{ if( var_y )
{ // result = variable^variable
CPPAD_ASSERT_UNKNOWN( NumRes(PowvvOp) == 3 );
CPPAD_ASSERT_UNKNOWN( NumArg(PowvvOp) == 2 );
// put operand addresses in tape
tape->Rec_.PutArg(x.taddr_, y.taddr_);
// put operator in the tape
result.taddr_ = tape->Rec_.PutOp(PowvvOp);
// make result a variable
result.id_ = tape->id_;
}
else if( IdenticalZero( y.value_ ) )
{ // result = variable^0
}
else
{ // result = variable^parameter
CPPAD_ASSERT_UNKNOWN( NumRes(PowvpOp) == 3 );
CPPAD_ASSERT_UNKNOWN( NumArg(PowvpOp) == 2 );
// put operand addresses in tape
size_t p = tape->Rec_.PutPar(y.value_);
tape->Rec_.PutArg(x.taddr_, p);
// put operator in the tape
result.taddr_ = tape->Rec_.PutOp(PowvpOp);
// make result a variable
result.id_ = tape->id_;
}
}
else if( var_y )
{ if( IdenticalZero(x.value_) )
{ // result = 0^variable
}
else
{ // result = variable^parameter
CPPAD_ASSERT_UNKNOWN( NumRes(PowpvOp) == 3 );
CPPAD_ASSERT_UNKNOWN( NumArg(PowpvOp) == 2 );
// put operand addresses in tape
size_t p = tape->Rec_.PutPar(x.value_);
tape->Rec_.PutArg(p, y.taddr_);
// put operator in the tape
result.taddr_ = tape->Rec_.PutOp(PowpvOp);
// make result a variable
result.id_ = tape->id_;
}
}
return result;
}
