DBFloat DBMathExpression::Float (DBObjRecord *record)
{
if (OperVAR == DBMathOperatorArgs) return (DBDefaultMissingFloatVal);
if (OperVAR == DBMathOperatorFunc)
{
DBFloat var;
double (*func) (double) = (double (*) (double)) RightPTR;
var = LeftPTR->Float (record);
return (CMmathEqualValues (var, DBDefaultMissingFloatVal) ?
DBDefaultMissingFloatVal : ((DBFloat) ((*func) ((double) var))));
}
if (OperVAR == DBMathOperatorCond)
{ return (((DBMathExpression *) RightPTR)->Float (record,LeftPTR->Int (record))); }
switch (TypeVAR)
{
case DBVariableInt:
{
DBInt lVar, rVar;
lVar = LeftPTR->Int (record);
rVar = RightPTR->Int (record);
if ((OperVAR != DBMathOperatorEqu) && (OperVAR != (DBMathOperatorSml | DBMathOperatorGrt)) &&
((lVar == DBDefaultMissingIntVal) || (rVar == DBDefaultMissingIntVal)))
return (DBDefaultMissingFloatVal);
switch (OperVAR)
{
case (DBMathOperatorAdd): return ((DBFloat) lVar + (DBFloat) rVar);
case (DBMathOperatorSub): return ((DBFloat) lVar - (DBFloat) rVar);
case (DBMathOperatorMul): return ((DBFloat) lVar * (DBFloat) rVar);
case (DBMathOperatorMod): return ((DBFloat) (lVar % rVar));
case (DBMathOperatorDiv): return ((DBFloat) lVar / (DBFloat) rVar);
case (DBMathOperatorExp): return ((DBFloat) pow ((double) lVar,(double) rVar));
default: break;
}
} break;
case DBVariableFloat:
{
DBFloat lVar, rVar;
lVar = LeftPTR->Float (record);
rVar = RightPTR->Float (record);
if ((OperVAR != DBMathOperatorEqu) && (OperVAR != (DBMathOperatorSml | DBMathOperatorGrt)) &&
(CMmathEqualValues (lVar,DBDefaultMissingFloatVal) ||
CMmathEqualValues (rVar,DBDefaultMissingFloatVal)))
return (DBDefaultMissingFloatVal);
switch (OperVAR)
{
case (DBMathOperatorAdd): return (lVar + rVar);
case (DBMathOperatorSub): return (lVar - rVar);
case (DBMathOperatorMul): return (lVar * rVar);
case (DBMathOperatorMod): return ((DBFloat) (fmod (lVar,rVar)));
case (DBMathOperatorDiv): return (lVar / rVar);
case (DBMathOperatorExp): return (pow (lVar,rVar));
default: break;
}
} break;
}
return (DBDefaultMissingFloatVal);
}
static void _MDDischRouteMuskingumCoeff (int itemID) {
// Input
float yMean; // Average depth at mean discharge [m]
float wMean; // River width at mean discharge [m]
float vMean; // Mean velocity
float beta; // Riverbed shape exponent []
float slope; // Riverbed slope [m/km]
// Output
float C0; // Muskingum C0 coefficient (current inflow)
float C1; // Muskingum C1 coefficient (previous inflow)
float C2; // MUskingum C2 coefficient (previous outflow)
// Local
float xi; // Flood-wave/flow velocity ratio
float C; // Cell Courant number;
float D; // Cell Reynolds number;
float dt; // time step length [s]
float dL; // Cell length [m]
dL = MFModelGetLength (itemID);
slope = MFVarGetFloat (_MDInRiverbedSlopeID, itemID, 0.0) / 1000.0;
yMean = MFVarGetFloat (_MDInRiverbedAvgDepthMeanID, itemID, 0.0);
wMean = MFVarGetFloat (_MDInRiverbedWidthMeanID, itemID, 0.0);
vMean = MFVarGetFloat (_MDInRiverbedVelocityMeanID, itemID, 0.0);
beta = MFVarGetFloat (_MDInRiverbedShapeExponentID, itemID, 0.0);
if (CMmathEqualValues (vMean, 0.0)) {
MFVarSetFloat (_MDOutMuskingumC0ID, itemID, 0.0);
MFVarSetFloat (_MDOutMuskingumC1ID, itemID, 0.0);
MFVarSetFloat (_MDOutMuskingumC2ID, itemID, 0.0);
MFVarSetFloat (_MDOutCourantID, itemID, 0.0);
return;
}
if (CMmathEqualValues (dL, 0.0) ||
CMmathEqualValues (slope, 0.0) ||
CMmathEqualValues (yMean, 0.0) ||
CMmathEqualValues (wMean, 0.0) ||
(beta < 0.0)) {
// Falling back to flow-accumulation
MFVarSetFloat (_MDOutMuskingumC0ID, itemID, 1.0);
MFVarSetFloat (_MDOutMuskingumC1ID, itemID, 0.0);
MFVarSetFloat (_MDOutMuskingumC2ID, itemID, 0.0);
MFVarSetFloat (_MDOutCourantID, itemID, 0.0);
return;
}
dt = MFModelGet_dt ();
xi = 1 + beta * (2.0 / 3.0) / (beta + 1);
C = xi * vMean * dt / dL;
D = yMean / (dL * slope * xi);
C0 = (-1 + C + D) / (1 + C + D);
C1 = ( 1 + C - D) / (1 + C + D);
C2 = ( 1 - C + D) / (1 + C + D);
// if ((C0 < 0.0) || (C1 < 0.0) || (C2 < 0.0)) { C0 = 1.0; C1 = 0; C2 = 0; } // According to Pounce C1 and C2 can be negative
MFVarSetFloat (_MDOutMuskingumC0ID, itemID, C0);
MFVarSetFloat (_MDOutMuskingumC1ID, itemID, C1);
MFVarSetFloat (_MDOutMuskingumC2ID, itemID, C2);
MFVarSetFloat (_MDOutCourantID, itemID, C);
}
DBInt RGlibGenFuncTopoAccum (DBObjTable *table,char *nextStnFldName,char *srcFldName,char *dstFldName)
{
DBInt rowID;
DBObjTableField *srcField, *dstField, *nextField;
DBObjRecord *record, *nextRec;
if (((srcField = table->Field (srcFldName)) == (DBObjTableField *) NULL) ||
((nextField =table->Field (nextStnFldName)) == (DBObjTableField *) NULL))
return (DBFault);
if ((dstField = table->Field (dstFldName)) == (DBObjTableField *) NULL)
{
dstField = new DBObjTableField (*srcField);
dstField->Name (dstFldName);
table->AddField (dstField);
}
for (rowID = 0;rowID < table->ItemNum ();++rowID)
{
record = table->Item (rowID);
dstField->Float (record,srcField->Float (record));
record->Flags (DBObjectFlagSelected,DBClear);
}
for (rowID = 0;rowID < table->ItemNum ();++rowID)
{
record = table->Item (rowID);
DBPause (rowID * 100 / table->ItemNum ());
if ((record->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle)
{
dstField->Float (record,dstField->FloatNoData ());
continue;
}
for (nextRec = table->Item (nextField->Int (record) - 1);
nextRec != (DBObjRecord *) NULL;
nextRec = table->Item (nextField->Int (nextRec) - 1))
{
if (nextRec == record) { record->Flags (DBObjectFlagSelected,DBSet); break; }
if ((nextRec->Flags () & DBObjectFlagIdle) != DBObjectFlagIdle)
{
if (CMmathEqualValues (dstField->Float (nextRec),dstField->FloatNoData ()) ||
CMmathEqualValues (srcField->Float (record),srcField->FloatNoData ()))
dstField->Float (nextRec,dstField->FloatNoData ());
else
dstField->Float (nextRec,dstField->Float (nextRec) + srcField->Float (record));
}
}
}
return (DBSuccess);
}
DBInt DBGridIF::Value (DBObjRecord *layerRec,DBPosition pos,DBFloat *value) const
{
DBInt j;
DBObjRecord *dataRec = LayerFLD->Record (layerRec);
DBFloat missingValue = MissingValueFLD->Float (ItemTable->Item (layerRec->RowID ()));
// if (pos.Col < 0) return (false); No longer possible
// if (pos.Row < 0) return (false);
if (pos.Col >= DimensionVAR.Col) return (false);
if (pos.Row >= DimensionVAR.Row) return (false);
j = DimensionVAR.Col * (DimensionVAR.Row - pos.Row - 1) + pos.Col;
switch (ValueTypeVAR)
{
case DBTableFieldFloat:
switch (ValueSizeVAR)
{
case sizeof (DBFloat4): *value = (DBFloat) ((DBFloat4 *) (dataRec->Data ())) [j]; break;
case sizeof (DBFloat): *value = (DBFloat) ((DBFloat *) (dataRec->Data ())) [j]; break;
}
break;
case DBTableFieldInt:
switch (ValueSizeVAR)
{
case sizeof (DBByte): *value = (DBFloat) ((DBByte *) (dataRec->Data ())) [j]; break;
case sizeof (DBShort): *value = (DBFloat) ((DBShort *) (dataRec->Data ())) [j]; break;
case sizeof (DBInt): *value = (DBFloat) ((DBInt *) (dataRec->Data ())) [j]; break;
}
break;
}
return (CMmathEqualValues (*value,missingValue) ? false : true);
}
char *DBObjTableField::String(const DBObjRecord *record) const {
static char retString[DBStringLength];
if (record == (DBObjRecord *) NULL) return ((char *) NULL);
switch (Type()) {
case DBTableFieldString:
return ((char *) record->Data() + StartByte());
case DBTableFieldInt: {
DBInt ret = Int(record);
if (ret == IntNoData()) return ((char *) "");
sprintf(retString, Format(), ret);
return (retString);
}
case DBTableFieldFloat: {
DBFloat ret = Float(record);
if (CMmathEqualValues(ret, FloatNoData())) return ((char *) "");
sprintf(retString, Format(), ret);
return (retString);
}
case DBTableFieldDate: {
DBDate date = Date(record);
strncpy(retString, date.Get(), sizeof(retString));
}
return (retString);
case DBTableFieldTableRec:
case DBTableFieldDataRec: {
DBObjRecord *refRecord = Record(record);
return (refRecord->Name());
}
default:
return (NULL);
}
}
DBInt RGlibPointSTNCoordinates(DBObjData *dbData, DBObjTableField *field) {
DBInt pointID, ret = DBFault;
DBCoordinate coord;
DBPosition pos;
DBObjData *linkedData = dbData->LinkedData();
DBVPointIF *pntIF;
DBNetworkIF *netIF;
DBObjRecord *pntRec, *cellRec;
if (linkedData == (DBObjData *) NULL) return (DBFault);
pntIF = new DBVPointIF(dbData);
netIF = new DBNetworkIF(linkedData);
for (pointID = 0; pointID < pntIF->ItemNum(); ++pointID) {
pntRec = pntIF->Item(pointID);
if (DBPause(pointID * 100 / pntIF->ItemNum())) goto Stop;
if ((pntRec->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle) continue;
coord = pntIF->Coordinate(pntRec);
if (netIF->Coord2Pos(coord, pos) == DBFault) continue;
netIF->Pos2Coord(pos, coord);
if ((field != (DBObjTableField *) NULL) &&
(!CMmathEqualValues(field->Float(pntRec), field->FloatNoData())) &&
((cellRec = netIF->Cell(coord, field->Float(pntRec))) != (DBObjRecord *) NULL))
coord = netIF->Center(cellRec);
pntIF->Coordinate(pntRec, coord);
}
ret = DBSuccess;
Stop:
delete netIF;
delete pntIF;
return (ret);
}
static void _MDRiverbedShapeExponent (int itemID) {
// Input
float slope; // Riverbed slope [m/km]
float discharge; // Mean annual discharge [m3/s]
float eta = 0.0;
float nu = 0.0;
float tau = 0.0;
float phi = 0.0;
// Output
float yMean; // River average depth at mean discharge [m]
float wMean; // River width at mean discharge [m]
// Local
float dL; // Reach length [m]
// float eta = 0.25, nu = 0.4, tau = 8.0, phi = 0.58; //old
// float eta = 0.36, nu = 0.37, tau = 3.55, phi = 0.51; //new based on Knighton (avg)
// float eta = 0.33, nu = 0.35, tau = 3.67, phi = 0.45; // Hey and Thorn (1986) (used for ERL 2013)
eta = MFVarGetFloat (_MDInEtaID, itemID, 0.0);
nu = MFVarGetFloat (_MDInNuID, itemID, 0.0);
tau = MFVarGetFloat (_MDInTauID, itemID, 0.0);
phi = MFVarGetFloat (_MDInPhiID, itemID, 0.0);
if (MFVarTestMissingVal (_MDInDischMeanID, itemID)) {
MFVarSetFloat (_MDOutRiverbedAvgDepthMeanID, itemID, 0.0);
MFVarSetFloat (_MDOutRiverbedWidthMeanID, itemID, 0.0);
MFVarSetFloat (_MDOutRiverbedVelocityMeanID, itemID, 0.0);
MFVarSetFloat (_MDOutRiverbedShapeExponentID, itemID, 2.0);
return;
}
discharge = fabs(MFVarGetFloat(_MDInDischMeanID, itemID, 0.0));
dL = MFModelGetLength (itemID);
if (CMmathEqualValues (dL, 0.0) || (_MDInRiverbedSlopeID == MFUnset) || MFVarTestMissingVal (_MDInRiverbedSlopeID, itemID)) {
// Slope independent riverbed geometry
yMean = eta * pow (discharge, nu);
wMean = tau * pow (discharge, phi);
// printf("eta = %f, nu = %f, tau = %f, phi = %f\n", eta, nu, tau, phi);
MFVarSetFloat (_MDOutRiverbedAvgDepthMeanID, itemID, yMean);
MFVarSetFloat (_MDOutRiverbedWidthMeanID, itemID, wMean);
MFVarSetFloat (_MDOutRiverbedVelocityMeanID, itemID, discharge / (yMean * wMean));
MFVarSetFloat (_MDOutRiverbedShapeExponentID, itemID, 2.0);
return;
}
// Slope dependent riverbed geometry
slope = MFVarGetFloat(_MDInRiverbedSlopeID, itemID, 0.01) / 1000.0;
yMean = eta * pow (discharge, nu);
wMean = tau * pow (discharge, phi);
// printf("eta = %f, nu = %f, tau = %f, phi = %f\n", eta, nu, tau, phi);
MFVarSetFloat (_MDOutRiverbedAvgDepthMeanID, itemID, yMean);
MFVarSetFloat (_MDOutRiverbedWidthMeanID, itemID, wMean);
MFVarSetFloat (_MDOutRiverbedVelocityMeanID, itemID, discharge / (yMean * wMean));
MFVarSetFloat (_MDOutRiverbedShapeExponentID, itemID, 2.0);
}
DBInt RGlibGenFuncFieldCompare(DBObjTable *table, char *f0Text, char *f1Text, char *rText, DBInt diffMethod) {
DBInt intVal, ret, i, rowID;
DBFloat val[2];
DBObjTableField *field[2];
DBObjTableField *result;
DBObjRecord *record;
field[0] = table->Field(f0Text);
field[1] = table->Field(f1Text);
result = table->Field(rText);
if ((field[0] == (DBObjTableField *) NULL) || (field[1] == (DBObjTableField *) NULL)) {
CMmsgPrint(CMmsgAppError, "Invalid Compare Fields in: %s %d", __FILE__, __LINE__);
return (DBFault);
}
if (result == (DBObjTableField *) NULL)
table->AddField(result = new DBObjTableField(rText, DBTableFieldFloat, "%10.3f", sizeof(DBFloat4)));
if (diffMethod > 0) result->Format("%6.2f");
for (rowID = 0; rowID < table->ItemNum(); ++rowID) {
record = table->Item(rowID);
if ((record->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle)
result->Float(record, result->FloatNoData());
else {
for (i = 0; i < 2; ++i)
if (field[i]->Type() == DBTableFieldInt) {
intVal = field[i]->Int(record);
ret = intVal == field[i]->IntNoData();
val[i] = (DBFloat) intVal;
}
else {
val[i] = field[i]->Float(record);
ret = CMmathEqualValues(val[i], field[i]->FloatNoData());
}
if (ret) result->Float(record, result->FloatNoData());
else
switch (diffMethod) {
default:
result->Float(record, val[0] - val[1]);
break;
case 1:
result->Float(record, (val[0] - val[1]) * 100.0 / val[0]);
break;
case 2:
result->Float(record, (val[0] - val[1]) * 100.0 / (val[0] > val[1] ? val[0] : val[1]));
break;
}
}
}
return (DBSuccess);
}
DBInt DBMathOperand::Int (DBObjRecord *record)
{
switch (OprTypeVAR)
{
case DBMathOperandConst:
switch (VarTypeVAR)
{
case DBVariableString: return (DBDefaultMissingIntVal);
case DBVariableInt: return (Var.Int);
case DBVariableFloat:
return (CMmathEqualValues (Var.Float,DBDefaultMissingFloatVal) ?
DBDefaultMissingIntVal : (DBInt) Var.Float);
}
case DBMathOperandVar: return (Var.FldPTR->Int (record));
case DBMathOperandExpr:
case DBMathOperandCond: return (Var.ExpPTR->Int (record));
default: break;
}
return (DBDefaultMissingIntVal);
}
static void _MDRiverbedShapeExponent (int itemID) {
// Input
float slope; // Riverbed slope [m/km]
float discharge; // Mean annual discharge [m3/s]
// Output
float yMean; // River average depth at mean discharge [m]
float wMean; // River width at mean discharge [m]
// Local
float dL; // Reach length [m]
float eta = 0.25, nu = 0.4, tau = 8.0, phi = 0.58;
if (MFVarTestMissingVal (_MDInDischMeanID, itemID)) {
MFVarSetFloat (_MDOutRiverbedAvgDepthMeanID, itemID, 0.0);
MFVarSetFloat (_MDOutRiverbedWidthMeanID, itemID, 0.0);
MFVarSetFloat (_MDOutRiverbedVelocityMeanID, itemID, 0.0);
MFVarSetFloat (_MDOutRiverbedShapeExponentID, itemID, 2.0);
return;
}
discharge = fabs(MFVarGetFloat(_MDInDischMeanID, itemID, 0.0));
dL = MFModelGetLength (itemID);
if (CMmathEqualValues (dL, 0.0) || (_MDInRiverbedSlopeID == MFUnset) || MFVarTestMissingVal (_MDInRiverbedSlopeID, itemID)) {
// Slope independent riverbed geometry
yMean = eta * pow (discharge, nu);
wMean = tau * pow (discharge, phi);
MFVarSetFloat (_MDOutRiverbedAvgDepthMeanID, itemID, yMean);
MFVarSetFloat (_MDOutRiverbedWidthMeanID, itemID, wMean);
MFVarSetFloat (_MDOutRiverbedVelocityMeanID, itemID, discharge / (yMean * wMean));
MFVarSetFloat (_MDOutRiverbedShapeExponentID, itemID, 2.0);
return;
}
// Slope dependent riverbed geometry
slope = MFVarGetFloat(_MDInRiverbedSlopeID, itemID, 0.01) / 1000.0;
yMean = eta * pow (discharge, nu);
wMean = tau * pow (discharge, phi);
MFVarSetFloat (_MDOutRiverbedAvgDepthMeanID, itemID, yMean);
MFVarSetFloat (_MDOutRiverbedWidthMeanID, itemID, wMean);
MFVarSetFloat (_MDOutRiverbedVelocityMeanID, itemID, discharge / (yMean * wMean));
MFVarSetFloat (_MDOutRiverbedShapeExponentID, itemID, 2.0);
}
bool NCaxisInitialize (int ncid, NCaxis_p axis, NCaxisType axisType, ut_system *utSystem) {
int status;
int varid;
int ndims;
size_t attlen, i;
char text [NC_MAX_NAME + 1];
double interval;
bool doUnits = true;
switch (axis->AxisType = axisType) {
case NCaxisX:
if (((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"x")) == CMfailed) &&
((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"X")) == CMfailed)) {
CMmsgPrint (CMmsgAppError, "Missing x axis variable in NetCDF file!\n");
return (false);
}
break;
case NCaxisY:
if (((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"y")) == CMfailed) &&
((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"Y")) == CMfailed)) {
CMmsgPrint (CMmsgAppError, "Missing y axis variable in NetCDF file!\n");
return (false);
}
break;
case NCaxisZ:
if (((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"z")) == CMfailed) &&
((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"Z")) == CMfailed)) {
axis->Dimid = 0;
if (((axis->Data = (double *) malloc (sizeof (double))) == (double *) NULL) ||
((axis->Bounds = (double *) malloc (sizeof (double) * 2)) == (double *) NULL)) {
CMmsgPrint (CMmsgSysError, "Memory allocation error in %s:%d!\n",__FILE__,__LINE__);
return (false);
}
axis->N = 1;
axis->Dimid = CMfailed;
axis->Data [0] = axis->Bounds [0] = axis->Bounds [1] = 0.0;
return (true);
}
break;
case NCaxisTime:
if (((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"t")) == CMfailed) &&
((varid = NCfindVariableByAttribute (ncid,1,NCaxisStr,"time")) == CMfailed)) {
CMmsgPrint (CMmsgAppError, "Missing time axis variable in NetCDF file!\n");
return (false);
}
break;
}
if (((status = nc_inq_varndims (ncid,varid,&ndims)) != NC_NOERR) || (ndims != 1) ||
((status = nc_inq_vardimid (ncid,varid,&(axis->Dimid))) != NC_NOERR) ||
((status = nc_inq_dimlen (ncid,axis->Dimid,&(axis->N))) != NC_NOERR)) {
CMmsgPrint (CMmsgAppError,"NetCDF variable dimension inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
if ((status = nc_inq_attlen (ncid,varid,NCaxisStr,&attlen)) == NC_NOERR) {
if ((axis->Axis = (char *) malloc (attlen + 1)) == (char *) NULL) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in: %s:%d!\n",__FILE__,__LINE__);
return (false);
}
if ((status = nc_get_att_text (ncid,varid,NCaxisStr,axis->Axis)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF attribute inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
else axis->Axis [attlen] = '\0';
}
if ((status = nc_inq_attlen (ncid,varid,NClongNameStr,&attlen)) == NC_NOERR) {
if ((axis->LongName = (char *) malloc (attlen + 1)) == (char *) NULL) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in: %s:%d!\n",__FILE__,__LINE__);
return (false);
}
if ((status = nc_get_att_text (ncid,varid,NClongNameStr,axis->LongName)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF attribute inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
else axis->LongName [attlen] = '\0';
}
if ((status = nc_inq_attlen (ncid,varid,NCstandardNameStr,&attlen)) == NC_NOERR) {
if ((axis->StandardName = (char *) malloc (attlen + 1)) == (char *) NULL) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in: %s:%d!\n",__FILE__,__LINE__);
return (false);
}
if ((status = nc_get_att_text (ncid,varid,NCstandardNameStr,axis->StandardName)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF attribute inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
else axis->StandardName [attlen] = '\0';
}
if (doUnits) {
if ((status = nc_inq_attlen (ncid,varid,NCunitsStr,&attlen)) == NC_NOERR) {
if (attlen > 0) {
if ((status = nc_get_att_text (ncid,varid,NCunitsStr,text)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF attribute inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
else text [attlen] = '\0';
if ((axis->Unit = ut_parse (utSystem, ut_trim (text, UT_ASCII), UT_ASCII)) == (ut_unit *) NULL) {
switch (ut_get_status ()) {
case UT_BAD_ARG: CMmsgPrint (CMmsgAppError, "System or string is NULL!\n"); break;
case UT_SYNTAX: CMmsgPrint (CMmsgAppError, "String contained a syntax error!n"); break;
case UT_UNKNOWN: CMmsgPrint (CMmsgAppError, "String contained an unknown identifier!\n"); break;
default: CMmsgPrint (CMmsgSysError, "System error in %s:%d!n",__FILE__,__LINE__);
}
}
}
}
}
if (((status = nc_inq_attlen (ncid,varid,NCpositiveStr,&attlen)) == NC_NOERR) && (attlen < NC_MAX_NAME)) {
if ((status = nc_get_att_text (ncid,varid,NCpositiveStr,text)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF attribute inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
else text [attlen] = '\0';
axis->Direction = strcmp (text,NCpositiveUpStr) == 0 ? NCdirUp : NCdirDown;
}
else axis->Direction = NCdirUp;
if (((axis->Data = (double *) malloc (axis->N * sizeof (double))) == (double *) NULL) ||
((axis->Bounds = (double *) malloc (axis->N * sizeof (double) * 2)) == (double *) NULL)) {
CMmsgPrint (CMmsgSysError,"Memory allocation error in: %s:%d!\n",__FILE__,__LINE__);
return (false);
}
if ((status = nc_get_var_double (ncid,varid,axis->Data)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF %s axis data loading error \"%s\" in %s:%d!\n",_NCaxisGetTypeString (axis->AxisType),nc_strerror (status),__FILE__,__LINE__);
return (false);
}
if (((status = nc_inq_attlen (ncid,varid,NCboundsStr, &attlen)) == NC_NOERR) && (attlen < NC_MAX_NAME)) {
if ((status = nc_get_att_text (ncid,varid,NCboundsStr,text)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF bounds attribute inquiring error \"%s\" in %s:%d!\n",nc_strerror (status),__FILE__,__LINE__);
return (false);
}
else text [attlen] = '\0';
if ((status = nc_inq_varid (ncid,text,&varid)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF bounds variable inquery error \"%s\" in %s:%d!\n", nc_strerror (status),__FILE__,__LINE__);
return (false);
}
if ((status = nc_get_var_double (ncid,varid,axis->Bounds)) != NC_NOERR) {
CMmsgPrint (CMmsgAppError,"NetCDF %s axis bounds loading error \"%s\" in %s:%d!\n",_NCaxisGetTypeString (axis->AxisType),nc_strerror (status),__FILE__,__LINE__);
return (false);
}
}
else {
for (i = 1;i < axis->N - 1; ++i) {
axis->Bounds [i * 2] = (axis->Data [i] + axis->Data [i - 1]) / 2.0;
axis->Bounds [i * 2 + 1] = (axis->Data [i + 1] + axis->Data [i]) / 2.0;
}
axis->Bounds [1] = axis->Bounds [2];
axis->Bounds [0] = axis->Data [0] - (axis->Bounds [1] - axis->Data [0]);
axis->Bounds [i * 2] = axis->Bounds [(i - 1) * 2 + 1];
axis->Bounds [i * 2 + 1] = axis->Data [i] + (axis->Data [i] - axis->Bounds [i * 2]);
}
axis->IntervalMin = axis->Bounds [i * 2 + 1] - axis->Bounds [0];
axis->IntervalMax = 0.0;
for (i = 0;i < axis->N; ++i) {
interval = axis->Bounds [i * 2 + 1] - axis->Bounds [i * 2];
axis->IntervalMin = CMmathMinimum (axis->IntervalMin,interval);
axis->IntervalMax = CMmathMaximum (axis->IntervalMax,interval);
}
axis->Regular = axis->N > 1 ? CMmathEqualValues (axis->IntervalMin,axis->IntervalMax) : true;
return (true);
}
int main(int argc, char *argv[]) {
int argPos, argNum = argc, ret = CMfailed, itemSize, i, bin, binNum = 1000, percent;
bool valueMode = false;
FILE *inFile = (FILE *) NULL, *outFile = stdout;
char *fileName = (char *) NULL;
void *items = (void *) NULL;
double *max = (double *) NULL;
double *min = (double *) NULL;
float *output = (float *) NULL;
int *bins = (int *) NULL;
double value, binSize, binMax, binMin, percentMin; /* percentMax */
MFdsHeader_t header, outHeader;
if (argNum < 2) goto Help;
for (argPos = 1; argPos < argNum;) {
if (CMargTest(argv[argPos], "-i", "--input")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
fileName = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos], "-b", "--bins")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
if (sscanf(argv[argPos], "%d", &binNum) != 1) {
CMmsgPrint(CMmsgUsrError, "Ilformed bin number!");
goto Stop;
}
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-m", "--mode")) {
int mode;
const char *modes[] = {"percent", "value", (char *) NULL};
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing savesteps!");
return (CMfailed);
}
if ((mode = CMoptLookup(modes, argv[argPos], true)) == CMfailed) {
CMmsgPrint(CMmsgUsrError, "Invalid savesteps mode!");
return (CMfailed);
}
valueMode = mode == 1 ? true : false;
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos], "-h", "--help")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) < argPos) break;
Help:
CMmsgPrint(CMmsgUsrError, "%s [options] <out datastream>", CMfileName(argv[0]));
CMmsgPrint(CMmsgUsrError, " -i, --input [input datastream]");
CMmsgPrint(CMmsgUsrError, " -b, --bins [# of bins]");
CMmsgPrint(CMmsgUsrError, " -m, --mode [percent|value]");
CMmsgPrint(CMmsgUsrError, " -h,--help");
ret = CMsucceeded;
goto Stop;
}
if ((argv[argPos][0] == '-') && (strlen(argv[argPos]) > 1)) {
CMmsgPrint(CMmsgUsrError, "Unknown option: %s!", argv[argPos]);
return (CMfailed);
}
argPos++;
}
if (argNum > 2) {
CMmsgPrint(CMmsgUsrError, "Extra arguments!");
goto Stop;
}
if (fileName == (char *) NULL) {
CMmsgPrint(CMmsgUsrError, "Missing input file!");
goto Stop;
}
if ((outFile = (argNum > 2) && (strcmp(argv[1], "-") != 0) ? fopen(argv[1], "w") : stdout) == (FILE *) NULL) {
CMmsgPrint(CMmsgSysError, "Output file opening error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
if ((inFile = fopen(fileName, "r")) == (FILE *) NULL) {
CMmsgPrint(CMmsgSysError, "Input file opening error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
while (MFdsHeaderRead(&header, inFile) == CMsucceeded) {
if (items == (void *) NULL) {
itemSize = MFVarItemSize(header.Type);
if ((items = (void *) calloc(header.ItemNum, itemSize)) == (void *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((max = (double *) calloc(header.ItemNum, sizeof(double))) == (double *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((min = (double *) calloc(header.ItemNum, sizeof(double))) == (double *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((output = (float *) calloc(header.ItemNum, sizeof(float))) == (float *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((bins = (int *) calloc(header.ItemNum * binNum, sizeof(int))) == (int *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
for (i = 0; i < header.ItemNum; i++) {
max[i] = -HUGE_VAL;
min[i] = HUGE_VAL;
for (bin = 0; bin < binNum; ++bin) bins[bin * header.ItemNum + i] = 0;
}
outHeader.Swap = 1;
outHeader.Type = MFFloat;
outHeader.ItemNum = header.ItemNum;
outHeader.Missing.Float = MFDefaultMissingFloat;
}
if ((int) fread(items, itemSize, header.ItemNum, inFile) != header.ItemNum) {
CMmsgPrint(CMmsgSysError, "Input reading error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
switch (header.Type) {
case MFByte:
for (i = 0; i < header.ItemNum; i++) {
if (((char *) items)[i] == header.Missing.Int) continue;
value = (double) (((char *) items)[i]);
if (max[i] < value) max[i] = value;
if (min[i] > value) min[i] = value;
}
break;
case MFShort:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapHalfWord(((short *) items) + i);
if (((short *) items)[i] == header.Missing.Int) continue;
value = (double) (((short *) items)[i]);
if (max[i] < value) max[i] = value;
if (min[i] > value) min[i] = value;
}
break;
case MFInt:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapWord(((int *) items) + i);
if (((int *) items)[i] == header.Missing.Int) continue;
value = (double) (((int *) items)[i]);
if (max[i] < value) max[i] = value;
if (min[i] > value) min[i] = value;
}
break;
case MFFloat:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapWord(((float *) items) + i);
if (CMmathEqualValues(((float *) items)[i], header.Missing.Float) == true) continue;
value = (double) (((float *) items)[i]);
if (max[i] < value) max[i] = value;
if (min[i] > value) min[i] = value;
}
break;
case MFDouble:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapLongWord(((double *) items) + i);
if (CMmathEqualValues(((double *) items)[i], header.Missing.Float) == true) continue;
value = (double) (((double *) items)[i]);
if (max[i] < value) max[i] = value;
if (min[i] > value) min[i] = value;
}
break;
}
}
if (ferror (inFile) != 0) {
CMmsgPrint(CMmsgSysError, "Input file reading error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
rewind(inFile);
while (MFdsHeaderRead(&header, inFile) == CMsucceeded) {
if ((int) fread(items, itemSize, header.ItemNum, inFile) != header.ItemNum) {
CMmsgPrint(CMmsgSysError, "Input reading error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
switch (header.Type) {
case MFByte:
for (i = 0; i < header.ItemNum; i++) {
if (((char *) items)[i] == header.Missing.Int) continue;
if (!CMmathEqualValues(max[i], min[i])) {
value = (double) (((char *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
for (; bin >= 0; bin--) bins[bin * header.ItemNum + i] += 1;
}
}
break;
case MFShort:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapHalfWord(((short *) items) + i);
if (((short *) items)[i] == header.Missing.Int) continue;
if (!CMmathEqualValues(max[i], min[i])) {
value = (double) (((short *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
for (; bin >= 0; bin--) bins[bin * header.ItemNum + i] += 1;
}
}
break;
case MFInt:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapWord(((int *) items) + i);
if (((int *) items)[i] == header.Missing.Int) continue;
if (!CMmathEqualValues(max[i], min[i])) {
value = (double) (((int *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
for (; bin >= 0; bin--) bins[bin * header.ItemNum + i] += 1;
}
}
break;
case MFFloat:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapWord(((float *) items) + i);
if (CMmathEqualValues(((float *) items)[i], header.Missing.Float) == true) continue;
if (!CMmathEqualValues(max[i], min[i])) {
value = (double) (((float *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
for (; bin >= 0; bin--) bins[bin * header.ItemNum + i] += 1;
}
}
break;
case MFDouble:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapLongWord(((double *) items) + i);
if (CMmathEqualValues(((double *) items)[i], header.Missing.Float) == true) continue;
if (!CMmathEqualValues(max[i], min[i])) {
value = (double) (((double *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
for (; bin >= 0; bin--) bins[bin * header.ItemNum + i] += 1;
}
}
break;
}
}
if (ferror (inFile) != 0) {
CMmsgPrint(CMmsgSysError, "Input file reading error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
if (valueMode) {
for (percent = 0; percent < 100; ++percent) {
for (i = 0; i < header.ItemNum; i++) {
binSize = (max[i] - min[i]) / (float) binNum;
if (CMmathEqualValues(binSize, 0.0)) output[i] = min[i];
else {
for (bin = 0; bin < binNum; ++bin) {
percentMin = bins[bin * header.ItemNum + i] / bins[i] * 100.0;
if ((float) percent > percentMin) break;
}
binMax = bin < binNum ? (float) bin * binSize + min[i] : max[i];
binMin = bin > 0 ? (float) (bin - 1) * binSize + min[i] : min[i];
// percentMax = bin < binNum ? bins [bin * header.ItemNum + i] / bins [i] * 100.0 : 100.0;
output[i] = (binMax + binMin) / 2.0;
}
}
sprintf(outHeader.Date, "%3d", percent + 1);
if (MFdsHeaderWrite (&outHeader, outFile) == CMsucceeded) {
CMmsgPrint(CMmsgSysError, "Output writing error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((int) fwrite(output, sizeof(float), outHeader.ItemNum, outFile) != outHeader.ItemNum) {
CMmsgPrint(CMmsgSysError, "Output reading error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
}
ret = CMsucceeded;
}
else {
rewind(inFile);
while (MFdsHeaderRead (&header, inFile) == CMsucceeded) {
if ((int) fread(items, itemSize, header.ItemNum, inFile) != header.ItemNum) {
CMmsgPrint(CMmsgSysError, "Input reading error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
switch (header.Type) {
case MFByte:
for (i = 0; i < header.ItemNum; i++) {
if (((char *) items)[i] == header.Missing.Int) output[i] = outHeader.Missing.Float;
else if (bins[i] > 0) {
value = (double) (((char *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
output[i] = 100.0 * (double) bins[bin * header.ItemNum + i] / (double) bins[i];
}
else output[i] = 100.0;
}
break;
case MFShort:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapHalfWord(((short *) items) + i);
if (((short *) items)[i] == header.Missing.Int) output[i] = outHeader.Missing.Float;
else if (bins[i] > 0) {
value = (double) (((short *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
output[i] = 100.0 * (double) bins[bin * header.ItemNum + i] / (double) bins[i];
}
else output[i] = 100.0;
}
break;
case MFInt:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapWord(((int *) items) + i);
if (((int *) items)[i] == header.Missing.Int) output[i] = outHeader.Missing.Float;
else if (bins[i] > 0) {
value = (double) (((int *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
output[i] = 100.0 * (double) bins[bin * header.ItemNum + i] / (double) bins[i];
}
else output[i] = 100.0;
}
break;
case MFFloat:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapWord(((float *) items) + i);
if (CMmathEqualValues(((float *) items)[i], header.Missing.Float) == true)
output[i] = outHeader.Missing.Float;
else if (bins[i] > 0) {
value = (double) (((float *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
output[i] = 100.0 * (double) bins[bin * header.ItemNum + i] / (double) bins[i];
}
else output[i] = 100.0;
}
break;
case MFDouble:
for (i = 0; i < header.ItemNum; i++) {
if (header.Swap != 1) MFSwapLongWord(((double *) items) + i);
if (CMmathEqualValues(((double *) items)[i], header.Missing.Float) == true)
output[i] = outHeader.Missing.Float;
else if (bins[i] > 0) {
value = (double) (((double *) items)[i]);
bin = (int) floor((double) (binNum - 1) * (value - min[i]) / (max[i] - min[i]));
output[i] = 100.0 * (double) bins[bin * header.ItemNum + i] / (double) bins[i];
}
else output[i] = 100.0;
}
break;
}
strcpy(outHeader.Date, header.Date);
if (MFdsHeaderWrite(&outHeader, outFile) == CMsucceeded) {
CMmsgPrint(CMmsgSysError, "Output writing error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((int) fwrite(output, sizeof(float), outHeader.ItemNum, outFile) != outHeader.ItemNum) {
CMmsgPrint(CMmsgSysError, "Output reading error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
}
if (ferror (inFile) != 0) {
CMmsgPrint(CMmsgSysError, "Input file reading error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
ret = CMsucceeded;
}
Stop:
if (items != (void *) NULL) free(items);
if (max != (double *) NULL) free(max);
if (min != (double *) NULL) free(min);
if (inFile != (FILE *) NULL) fclose(inFile);
if (outFile != stdout) fclose(outFile);
return (ret);
}
DBInt RGlibGenFuncFieldCalculate (DBObjTable *table,char *f0Text,char *f1Text,char *rText,DBInt oper)
{
DBInt intVal, ret = false, i, rowID;
DBFloat val [2];
DBObjTableField *field [2];
DBObjTableField *result;
DBObjRecord *record;
field [0] = table->Field (f0Text);
field [1] = table->Field (f1Text);
result = table->Field (rText);
if ((field [0] == (DBObjTableField *) NULL) && (sscanf (f0Text,"%lf",val) != 1)) return (DBFault);
if ((field [1] == (DBObjTableField *) NULL) && (sscanf (f1Text,"%lf",val + 1) != 1)) return (DBFault);
if (result == (DBObjTableField *) NULL)
table->AddField (result = new DBObjTableField (rText,DBTableFieldFloat,"%10.3f",sizeof (DBFloat4)));
if (field [0] != (DBObjTableField *) NULL)
result->Format (field [0]->Format ());
else if (field [1] != (DBObjTableField *) NULL)
result->Format (field [1]->Format ());
for (rowID = 0;rowID < table->ItemNum ();++rowID)
{
record = table->Item (rowID);
if ((record->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle)
result->Float (record,result->FloatNoData ());
else
{
for (i = 0;i < 2;++i)
if (field [i] != (DBObjTableField *) NULL)
{
ret = false;
if (field [i]->Type () == DBTableFieldInt)
{
intVal = field [i]->Int (record);
val [i] = (DBFloat) intVal;
ret = intVal == field [i]->IntNoData ();
}
else
{
val [i] = field [i]->Float (record);
ret = CMmathEqualValues (val [i],field [i]->FloatNoData ());
}
if (ret)
{
result->Float (record,result->FloatNoData ());
goto Continue;
}
}
if ((oper == DBMathOperatorDiv) && (val [1] == 0))
result->Float (record,result->FloatNoData ());
else
switch (oper)
{
case DBMathOperatorAdd: result->Float (record, val [0] + val [1]); break;
case DBMathOperatorSub: result->Float (record, val [0] - val [1]); break;
case DBMathOperatorMul: result->Float (record, val [0] * val [1]); break;
case DBMathOperatorDiv: result->Float (record, val [0] / val [1]); break;
default: CMmsgPrint (CMmsgAppError, "Invalid Operand in: %s %d",__FILE__,__LINE__); break;
}
Continue:
continue;
}
}
return (DBSuccess);
}
int main (int argc,char *argv [])
{
int argPos, argNum = argc, numGrpNames = 0, i = 0;
char **groupnames, *rename = (char *) NULL, *tableName = (char *) NULL;
bool ascii = false;
FieldOptions *head = (FieldOptions *) NULL, *p = (FieldOptions *) NULL, *temp = (FieldOptions *) NULL;
Groups **groups = (Groups **) NULL;
FILE *outFile = (FILE *) NULL;
DBObjData *inData, *outData;
DBObjTable *inTable, *outTable;
DBObjTableField *field;
DBObjRecord *inRecord, *outRecord;
DBObjectLIST<DBObjTableField> *fields;
if(argc <= 2) { doHelp(false,argv[0]); return(DBSuccess); }
outData = new DBObjData("Untitled", DBTypeTable);
outTable = outData->Table(DBrNItems);
head = new FieldOptions(BAD,"","", (FieldOptions *) NULL);
groupnames = (char **) malloc(sizeof(char *));
for (argPos = 1;argPos < argNum;)
{
if (CMargTest(argv[argPos],"-f","--field"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing operation and field after -f!"); return (CMfailed); }
if(!strcmp(argv[argPos],"pct"))
{
if (argNum <= argPos + 2)
{ CMmsgPrint (CMmsgUsrError,"Missing field and/or percentage after -f pct!"); return (CMfailed); }
p = FOHierarchy(argv[argPos],argv[argPos+1],rename,atoi(argv[argPos+2]),head);
argNum = CMargShiftLeft(argPos,argv,argNum);
argNum = CMargShiftLeft(argPos,argv,argNum);
}
else if(!strcmp(argv[argPos],"num"))
{
char *num = new char[4];
strcpy(num,"Num");
p = FOHierarchy(argv[argPos],num,rename,-1,head);
}
else
{
if (argNum < argPos + 1)
{ CMmsgPrint (CMmsgUsrError,"Missing operation or field after -f %s!",argv[argPos]); return (CMfailed); }
p = FOHierarchy(argv[argPos],argv[argPos+1],rename,-1,head);
argNum = CMargShiftLeft(argPos,argv,argNum);
}
p->setPrint(true);
rename = (char *) NULL;
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-g","--group"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing groupname!"); return (CMfailed); }
if((groupnames = (char **) realloc(groupnames,(numGrpNames + 1) * sizeof(char *))) == (char **) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return(DBFault); }
groupnames[numGrpNames] = argv[argPos];
numGrpNames++;
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-h","--help"))
{
argNum = CMargShiftLeft (argPos,argv,argNum);
if(CMargTest(argv[argPos],"e","extend"))
{
doHelp(true,argv[0]);
argNum = CMargShiftLeft (argPos,argv,argNum);
}
else doHelp(false,argv[0]);
}
if (CMargTest(argv[argPos],"-c","--ascii"))
{
ascii = true;
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-a","--table"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing table name!"); return (CMfailed); }
tableName = argv[argPos];
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-r","--rename"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing field after -r!"); return (CMfailed); }
rename = argv[argPos];
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-o","--output"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing output filename!"); return (CMfailed); }
if((outFile = fopen(argv[argPos],"w")) == (FILE *) NULL)
{ CMmsgPrint (CMmsgUsrError,"Cannot open file %s",argv[argPos]); return (CMfailed); }
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-t","--title"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing title!"); return (CMfailed); }
outData->Name(argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-s","--subject"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing subject!"); return (CMfailed); }
outData->Document(DBDocSubject,argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-d","--domain"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing domain!"); return (CMfailed); }
outData->Document(DBDocGeoDomain,argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if (CMargTest(argv[argPos],"-v","--version"))
{
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos)
{ CMmsgPrint (CMmsgUsrError,"Missing version!"); return (CMfailed); }
outData->Document(DBDocVersion,argv[argPos]);
if ((argNum = CMargShiftLeft(argPos,argv,argNum)) <= argPos) break;
continue;
}
if ((argv[argPos][0] == '-') && (strlen (argv[argPos]) > 1))
{ CMmsgPrint (CMmsgUsrError, "Unknown option: %s!",argv[argPos]); return (CMfailed); }
argPos++;
}
if(outFile == (FILE *) NULL) outFile = stdout;
if(head->next == (FieldOptions *) NULL) return(DBSuccess);
inData = new DBObjData();
if ((argNum > 1) && (strcmp(argv[1],"-") != 0)) inData->Read(argv[1]);
else inData->Read(stdin);
if (outData->Name() == (char *) NULL) outData->Name("Untitled");
if (outData->Document(DBDocSubject) == (char *) NULL) outData->Document(DBDocSubject,inData->Document(DBDocSubject));
if (outData->Document(DBDocGeoDomain) == (char *) NULL) outData->Document(DBDocGeoDomain,inData->Document(DBDocGeoDomain));
if (outData->Document(DBDocVersion) == (char *) NULL) outData->Document(DBDocVersion,inData->Document(DBDocVersion));
if(tableName == (char *) NULL) tableName = DBrNItems;
if((inTable = inData->Table(tableName)) == (DBObjTable *) NULL)
{ CMmsgPrint (CMmsgUsrError,"Invalid table!"); delete inData; return (CMfailed); }
if((groups = (Groups **) malloc(numGrpNames * sizeof(Groups *))) == (Groups **) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return(DBFault); }
for(i = 0; i < numGrpNames; i++)
{
if((field = inTable->Field(groupnames[i])) == (DBObjTableField *) NULL)
{ CMmsgPrint (CMmsgUsrError, "Invalid group name: %s",groupnames[i]); return (CMfailed); }
if(DBTableFieldIsCategory(field))
{
groups[i] = new Groups();
groups[i]->srcFLD = field;
groups[i]->dstFLD = new DBObjTableField(*field);
outTable->AddField(groups[i]->dstFLD);
// CMmsgPrint (CMmsgUsrError, "Added Group: %s",groups[i]->dstFLD->Name());
}
else CMmsgPrint (CMmsgUsrError, "Group %s is not Category!",groupnames[i]);
}
delete groupnames;
p = head->next;
temp = head;
while(p->next)
{
FieldOptions *duplicate = (FieldOptions *) NULL, *prev = p;
if(!p->getPrint() && FLDExists(p,p->getOldName(),p->getFunc(),&duplicate))
{ temp->next = p->next; delete p; p = temp->next; continue; }
while(FLDExists(prev,prev->getOldName(),prev->getFunc(),&prev,&duplicate) && !duplicate->getPrint())
{ prev->next = duplicate->next; delete duplicate; }
temp = p;
p = p->next;
}
// p = head->next;
// while(p) { CMmsgPrint (CMmsgUsrError, "Added: o:%s n:%s p:",p->getOldName(),p->getNewName()); if(p->getPrint()) CMmsgPrint (CMmsgUsrError, "true"); else CMmsgPrint (CMmsgUsrError, "false"); p = p->next; }
fields = inTable->Fields();
p = head->next;
while(p)
{
field = fields->Item (p->getOldName());
if (p->getFunc() == MIN || p->getFunc() == MAX)
p->field = new DBObjTableField(p->getNewName(),field->Type(),field->Format(),field->Length());
else if(p->getFunc() == NUM || p->getFunc() == NONNULL)
p->field = new DBObjTableField(p->getNewName(), DBTableFieldInt, DBHiddenField, sizeof (DBInt));
else p->field = new DBObjTableField(p->getNewName(), DBTableFieldFloat, DBHiddenField, sizeof(DBFloat));
if(p->getFunc() != NUM && p->getFunc() != NONNULL)
{
// if ((field = inTable->Field(p->getOldName())) == (DBObjTableField *) NULL)
if (field == (DBObjTableField *) NULL)
{
CMmsgPrint (CMmsgUsrError, "Invalid field name: %s",p->getOldName());
return(DBFault);
}
if (!DBTableFieldIsNumeric(field))
{
CMmsgPrint (CMmsgUsrError, "Field is not Numeric: %s",p->getOldName());
return(DBFault);
}
}
outTable->AddField(p->field);
p = p->next;
}
// MAKE SURE TO TEST FOR SPEED BY DECLARING INTS OUTSIDE OF FOR LOOPS!!!
for (int inRecID = 0;inRecID < inTable->ItemNum();++inRecID)
{
inRecord = inTable->Item(inRecID);
if ((outRecord = FindMatch(inRecord, outTable,(const Groups**) groups, numGrpNames)) != (DBObjRecord *) NULL)
{
p = head->next;
while(p)
{
field = fields->Item (p->getOldName());
switch(p->getFunc())
{
default:
break;
case NUM:
p->field->Int(outRecord,p->field->Int(outRecord) + 1);
break;
case NONNULL:
if (p->isInt())
{
if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,p->field->Int(outRecord) + 1);
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Int(outRecord,p->field->Int(outRecord) + 1);
}
break;
case MIN:
if (p->isInt())
{
if(field->Int(inRecord) != field->IntNoData())
{
if (p->field->Int(outRecord) != p->field->IntNoData())
{ if (field->Int(inRecord) < p->field->Int(outRecord)) p->field->Int(outRecord,field->Int(inRecord)); }
else { p->field->Int(outRecord,field->Int(inRecord)); }
}
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
{
if (!CMmathEqualValues(p->field->Float(inRecord),p->field->FloatNoData()))
{ if (field->Float(inRecord) < p->field->Float(outRecord)) p->field->Float(outRecord,field->Float(inRecord)); }
else { p->field->Float(outRecord,field->Float(inRecord)); }
}
}
break;
case MAX:
if (p->isInt())
{
if(field->Int(inRecord) != field->IntNoData())
{
if (p->field->Int(outRecord) != p->field->IntNoData())
{ if (field->Int(inRecord) > p->field->Int(outRecord)) p->field->Int(outRecord,field->Int(inRecord)); }
else { p->field->Int(outRecord,field->Int(inRecord)); }
}
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
{
if (!CMmathEqualValues(p->field->Float(inRecord),p->field->FloatNoData()))
{ if (field->Float(inRecord) > p->field->Float(outRecord)) p->field->Float(outRecord,field->Float(inRecord)); }
else { p->field->Float(outRecord,field->Float(inRecord)); }
}
}
break;
case SUM:
if (p->isInt())
{
if(field->Int(inRecord) != field->IntNoData())
p->field->Int(outRecord,p->field->Int(outRecord) + field->Int(inRecord));
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Float(outRecord,p->field->Float(outRecord) + field->Float(inRecord));
}
break;
case DEV:
case PCT:
case MED:
p->tailVal = p->tailVal->next = new Values();
p->tailVal->val = field->Float(inRecord);
p->tailVal->next = 0;
break;
case MOD:
Values *cur = p->getHead();
while(cur->next && !CMmathEqualValues(cur->val,field->Float(inRecord))) cur = cur->next;
if(cur->next) cur->occur++;
else
{
p->tailVal->val = field->Float(inRecord);
p->tailVal->occur = 1;
p->tailVal = p->tailVal->next = new Values();
}
break;
}
p = p->next;
}
}
else
{
outRecord = outTable->Add();
for(i = 0; i < numGrpNames; i++)
{
switch (groups[i]->srcFLD->Type())
{
default:
case DBTableFieldString:
groups[i]->dstFLD->String(outRecord,groups[i]->srcFLD->String(inRecord));
break;
case DBTableFieldInt:
groups[i]->dstFLD->Int(outRecord,groups[i]->srcFLD->Int(inRecord));
break;
}
}
p = head->next;
while(p)
{
field = fields->Item (p->getOldName());
switch(p->getFunc())
{
default:
case BAD:
break;
case NUM:
p->setInt();
p->field->Int(outRecord,1);
break;
case NONNULL:
if (field->Type() == DBTableFieldInt)
{
p->setInt();
if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,1);
else p->field->Int(outRecord,0);
}
else
{
if (!CMmathEqualValues(field->Float(inRecord),field->FloatNoData())) p->field->Int(outRecord,1);
else p->field->Int(outRecord,0);
}
break;
case MIN:
if (field->Type() == DBTableFieldInt)
{ p->setInt(); if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,field->Int(inRecord)); }
else
{
if(!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Float(outRecord,field->Float(inRecord));
}
break;
case MAX:
if (field->Type() == DBTableFieldInt)
{ p->setInt(); if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,field->Int(inRecord)); }
else
{
if(!CMmathEqualValues(field->Float(inRecord),field->FloatNoData()))
p->field->Float(outRecord,field->Float(inRecord));
}
break;
case SUM:
if (field->Type() == DBTableFieldInt)
{
p->setInt();
if (field->Int(inRecord) != field->IntNoData()) p->field->Int(outRecord,field->Int(inRecord));
else p->field->Int(outRecord,0);
}
else
{
if(!CMmathEqualValues(field->Float(inRecord),field->FloatNoData())) p->field->Float(outRecord,field->Float(inRecord));
else p->field->Float(outRecord,0.0);
}
break;
case DEV:
case PCT:
case MED:
p->tailVal = p->tailVal->next = new Values();
p->tailVal->val = field->Float(inRecord);
p->tailVal->next = 0;
break;
case MOD:
p->tailVal->val = field->Float(inRecord);
p->tailVal->occur = 1;
p->tailVal = p->tailVal->next = new Values();
break;
}
p = p->next;
}
}
}
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
outRecord = outTable->Item(outRecID);
p = head->next;
FieldOptions *sum, *num;
DBFloat mod;
int occurrance;
float i;
bool mult;
Values *cur;
while(p)
{
field = fields->Item (p->getOldName());
switch(p->getFunc())
{
case AVG:
if((FLDExists(head,p->getOldName(),SUM,&sum)) && (FLDExists(head,p->getOldName(),NONNULL,&num)))
p->field->Float(outRecord,sum->field->Float(outRecord) / (DBFloat) (num->field->Int(outRecord)));
else CMmsgPrint (CMmsgUsrError, "Program Error! Could not find SUM or NONNULL in linked list! Please contact the GHAAS developers group!");
break;
case NAVG:
if((FLDExists(head,p->getOldName(),SUM,&sum)) && (FLDExists(head,"NUM",NUM,&num)))
p->field->Float(outRecord,sum->field->Float(outRecord) / (DBFloat) (num->field->Int(outRecord)));
else CMmsgPrint (CMmsgUsrError, "Program Error! Could not find SUM or NUM in linked list! Please contact the GHAAS developers group!");
break;
case PCT:
case MED:
i = (float) (inTable->ItemNum() * p->getHead()->occur * 0.01) - 1;
cur = p->getHead()->next;
while(i > 0) { cur = cur->next; i--; }
p->field->Float(outRecord,(cur->val + cur->next->val) / 2);
break;
case MOD:
mod = 0.0;
occurrance = 0;
mult = false;
cur = p->getHead();
while(cur)
{
if(cur->occur > occurrance)
{
mod = cur->val;
occurrance = cur->occur;
mult = false;
}
else if(cur->occur == occurrance) mult = true;
cur = cur->next;
}
if(mult) CMmsgPrint (CMmsgUsrError, "** Warning, multiple answers for MOD, listing first found!");
p->field->Float(outRecord,mod);
break;
default:
break;
}
p = p->next;
}
}
p = head->next;
while(p)
{
if(p->getFunc() == DEV)
{
FieldOptions *avg, *num;
field = fields->Item (p->getOldName());
if((FLDExists(head,p->getOldName(),AVG,&avg)) && (FLDExists(head,"NUM",NUM,&num)))
{
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
outRecord = outTable->Item(outRecID);
DBFloat sum = 0.0;
Values *cur = p->getHead()->next;
while(cur)
{
// sum += (DBFloat) (pow((cur->val - avg->field->Float(outRecord)),2));
DBFloat add = (cur->val - avg->field->Float(outRecord));
sum += (DBFloat) (add * add);
cur = cur->next;
}
sum = sqrt(sum /(DBFloat) num->field->Int(outRecord));
p->field->Float(outRecord,sum);
}
}
else CMmsgPrint (CMmsgUsrError, "Program Error! Could not find AVG or NUM in linked list! Please contact the GHAAS developers group!");
}
p = p->next;
}
// DELETE unnecessary fields which were for temp storage
fields = outTable->Fields();
p = head->next;
while(p)
{
if(!p->getPrint()) outTable->DeleteField(fields->Item(p->getNewName()));
p = p->next;
}
p = head->next;
while(p)
{
if ((strcmp(p->field->Format(),DBHiddenField) == 0) && p->getPrint())
{
if(p->isInt())
{
int maxval = 0;
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
int val = p->field->Int(outTable->Item(outRecID));
if (maxval < val) maxval = val; else if (maxval < -val) maxval = -val;
}
p->field->Format(DBMathIntAutoFormat(maxval));
}
else
{
float maxval = 0.0;
for(int outRecID = 0; outRecID < outTable->ItemNum();++outRecID)
{
float val = p->field->Float(outTable->Item(outRecID));
if (maxval < val) maxval = val; else if (maxval < -val) maxval = -val;
}
p->field->Format(DBMathFloatAutoFormat(maxval));
}
}
// CMmsgPrint (CMmsgUsrError, "Format(%s)%d,%d: '%s'",p->getFuncName(),p->isInt(),p->getPrint(),p->field->Format());
p = p->next;
}
DBObjectLIST<DBObjTableField> *list = new DBObjectLIST<DBObjTableField> ("Sorted Field List");
for(i = 0; i < numGrpNames; i++) list->Add(groups[i]->dstFLD);
outTable->ListSort(list);
if (ascii) DBExportASCIITable(outTable,outFile); else outData->Write(outFile);
/* CLEANUP ************************************************/
if(outFile != stdout) fclose(outFile);
for(i = 0; i < numGrpNames; i++) delete groups[i]->dstFLD;
delete groups;
p = head;
while(p)
{
head = head->next;
delete p;
p = head;
}
return(DBSuccess);
}
DBInt DBGridIF::Value(DBObjRecord *layerRec, DBCoordinate coord, DBFloat *value) const {
DBInt i, j, pointNum;
DBInt row[9], col[9];
DBPosition pos;
DBCoordinate cellCoord;
DBPosition cellPos;
DBFloat precision, dist, wAvg, sumWeight, retVal;
DBObjRecord *dataRec = LayerFLD->Record(layerRec);
DBFloat missingValue = MissingValueFLD->Float(ItemTable->Item());
DBMathDistanceFunction distFunc = DBMathGetDistanceFunction(DataPTR);
if (DataPTR->Extent().InRegion(coord) == false) return (false);
precision = pow((double) 10.0, (double) DataPTR->Precision());
Coord2Pos(coord, cellPos);
Pos2Coord(cellPos, cellCoord);
if (Flat ||
((fabs(coord.X - cellCoord.X) < precision) &&
(fabs(coord.Y - cellCoord.Y) < precision))) {
j = DimensionVAR.Col * (DimensionVAR.Row - cellPos.Row - 1) + cellPos.Col;
switch (ValueTypeVAR) {
case DBTableFieldFloat:
switch (ValueSizeVAR) {
case sizeof(DBFloat4):
retVal = (DBFloat) ((DBFloat4 *) (dataRec->Data()))[j];
break;
case sizeof(DBFloat):
retVal = (DBFloat) ((DBFloat *) (dataRec->Data()))[j];
break;
}
break;
case DBTableFieldInt:
switch (ValueSizeVAR) {
case sizeof(DBByte):
retVal = (DBFloat) ((DBByte *) (dataRec->Data()))[j];
break;
case sizeof(DBShort):
retVal = (DBFloat) ((DBShort *) (dataRec->Data()))[j];
break;
case sizeof(DBInt):
retVal = (DBFloat) ((DBInt *) (dataRec->Data()))[j];
break;
}
break;
}
if (!CMmathEqualValues(retVal, missingValue)) {
*value = retVal;
return (true);
}
}
col[0] = cellPos.Col;
row[0] = cellPos.Row;
if (coord.X < cellCoord.X) col[0] -= 1;
if (coord.Y < cellCoord.Y) row[0] -= 1;
col[1] = col[0] + 1;
row[1] = row[0];
col[2] = col[0] + 1;
row[2] = row[0] + 1;
col[3] = col[0];
row[3] = row[0] + 1;
pos.Col = col[0];
pos.Row = row[0];
Pos2Coord(pos, cellCoord);
if ((coord.X - cellCoord.X) > (3.0 * CellWidth() / 4.0)) i = 1;
else if ((coord.X - cellCoord.X) > (CellWidth() / 4.0)) i = 0;
else i = -1;
if ((coord.Y - cellCoord.Y) > (3.0 * CellHeight() / 4.0)) j = 1;
else if ((coord.Y - cellCoord.Y) > (CellHeight() / 4.0)) j = 0;
else j = -1;
if ((i != 0) || (j != 0)) {
if (i == 0) {
row[4] = row[5] = j > 0 ? row[2] + 1 : row[0] - 1;
col[4] = col[0];
col[5] = col[2];
pointNum = 6;
}
else if (j == 0) {
row[4] = row[0];
row[5] = row[2];
col[4] = col[5] = i > 0 ? col[2] + 1 : col[0] - 1;
pointNum = 6;
}
else {
row[7] = row[0];
row[8] = row[2];
if (j > 0)
row[4] = row[5] = row[6] = row[2] + 1;
else
row[4] = row[5] = row[6] = row[0] - 1;
if (i > 0) {
col[4] = col[0];
col[5] = col[2];
col[6] = col[7] = col[8] = col[2] + 1;
}
else {
col[5] = col[0];
col[6] = col[2];
col[4] = col[7] = col[8] = col[0] - 1;
}
pointNum = 9;
}
}
else pointNum = 4;
wAvg = sumWeight = 0.0;
for (i = 0; i < pointNum; ++i) {
if (col[i] < 0) continue;
if (row[i] < 0) continue;
if (col[i] >= DimensionVAR.Col) continue;
if (row[i] >= DimensionVAR.Row) continue;
j = DimensionVAR.Col * (DimensionVAR.Row - row[i] - 1) + col[i];
switch (ValueTypeVAR) {
case DBTableFieldFloat:
switch (ValueSizeVAR) {
case sizeof(DBFloat4):
retVal = (DBFloat) ((DBFloat4 *) (dataRec->Data()))[j];
break;
case sizeof(DBFloat):
retVal = (DBFloat) ((DBFloat *) (dataRec->Data()))[j];
break;
}
break;
case DBTableFieldInt:
switch (ValueSizeVAR) {
case sizeof(DBByte):
retVal = (DBFloat) ((DBByte *) (dataRec->Data()))[j];
break;
case sizeof(DBShort):
retVal = (DBFloat) ((DBShort *) (dataRec->Data()))[j];
break;
case sizeof(DBInt):
retVal = (DBFloat) ((DBInt *) (dataRec->Data()))[j];
break;
}
break;
}
if (CMmathEqualValues(retVal, missingValue)) {
if ((col[i] == cellPos.Col) && (row[i] == cellPos.Row)) return (false);
else continue;
}
pos.Row = (DBUShort) row[i];
pos.Col = (DBUShort) col[i];
Pos2Coord(pos, cellCoord);
if (pointNum > 1) {
dist = DBMathCoordinateDistance(distFunc, coord, cellCoord);
dist *= dist;
}
else dist = 1.0;
wAvg = wAvg + retVal / dist;
sumWeight = sumWeight + 1.0 / dist;
}
if (sumWeight > 0) {
*value = wAvg / sumWeight;
return (true);
}
else {
*value = missingValue;
return (false);
}
}
int MFDataStreamRead (MFVariable_t *var) {
int i, sLen;
MFVarHeader_t header;
if (var->InStream->Type == MFConst) {
if (var->Header.ItemNum < 1) {
sLen = strlen (var->InPath);
for (i = strlen (MFconstStr);i < sLen;++i) if (var->InPath [i] == '.') break;
if (i == sLen) {
if (sscanf (var->InPath + strlen (MFconstStr),"%d",&(var->InStream->Handle.Int)) != 1) {
CMmsgPrint (CMmsgAppError,"Error: Reading constant [%s]!\n",var->Name);
return (CMfailed);
}
if (var->InStream->Handle.Int < 127) {
var->Header.DataType = MFByte;
var->Header.Missing.Int = MFDefaultMissingByte;
}
else if (var->InStream->Handle.Int < 32767) {
var->Header.DataType = MFShort;
var->Header.Missing.Int = MFDefaultMissingInt;
}
else {
var->Header.DataType = MFInt;
var->Header.Missing.Int = MFDefaultMissingInt;
}
if (var->Header.Missing.Int == var->InStream->Handle.Int) var->Header.Missing.Int = (int) 0;
}
else {
var->Header.DataType = MFFloat;
if (sscanf (var->InPath + strlen (MFconstStr),"%lf",&var->InStream->Handle.Float) != 1) {
CMmsgPrint (CMmsgAppError,"Error: Reading constant [%s]!\n",var->Name);
return (CMfailed);
}
var->Header.Missing.Float = CMmathEqualValues (var->InStream->Handle.Float,MFDefaultMissingFloat) ?
(float) 0.0 : MFDefaultMissingFloat;
}
}
strcpy (var->Header.Date,MFDateClimatologyStr);
}
else {
if (var->InStream->Handle.File == (FILE *) NULL) return (CMfailed);
if (!MFVarReadHeader (&header,var->InStream->Handle.File)) return (MFStop);
if (var->Data == (void *) NULL) {
if ((var->Data = (void *) realloc (var->Data,header.ItemNum * MFVarItemSize (header.DataType))) == (void *) NULL) {
CMmsgPrint (CMmsgSysError,"Variable [%s] allocation error in: %s:%d\n",var->Name,__FILE__,__LINE__);
return (CMfailed);
}
var->Header.ItemNum = header.ItemNum;
var->Header.DataType = header.DataType;
switch (var->Header.DataType) {
case MFByte:
case MFShort:
case MFInt: var->Header.Missing.Int = header.Missing.Int; break;
case MFFloat:
case MFDouble: var->Header.Missing.Float = header.Missing.Float; break;
}
}
else if (header.DataType != var->Header.DataType) {
CMmsgPrint (CMmsgAppError,"Record Type Missmatch [%d,%d] in: %s:%d varName %s \n", header.DataType, var->Header.DataType,__FILE__,__LINE__, var->Name);
return (CMfailed);
}
else if (header.ItemNum != var->Header.ItemNum) {
CMmsgPrint (CMmsgAppError,"Record Size Missmatch [%d,%d] in: %s:%d\n", header.ItemNum, var->Header.ItemNum, __FILE__,__LINE__);
return (CMfailed);
}
if ((int) fread (var->Data,MFVarItemSize (header.DataType),header.ItemNum,var->InStream->Handle.File) != header.ItemNum) {
CMmsgPrint (CMmsgSysError,"Data Reading error in: %s:%d\n",__FILE__,__LINE__);
return (CMfailed);
}
strncpy (var->Header.Date, header.Date, sizeof (header.Date));
if (header.Swap != 1)
switch (header.DataType) {
case MFShort: for (i = 0;i < var->Header.ItemNum;++i) MFSwapHalfWord ((short *) (var->Data) + i); break;
case MFInt: for (i = 0;i < var->Header.ItemNum;++i) MFSwapWord ((int *) (var->Data) + i); break;
case MFFloat: for (i = 0;i < var->Header.ItemNum;++i) MFSwapWord ((float *) (var->Data) + i); break;
case MFDouble: for (i = 0;i < var->Header.ItemNum;++i) MFSwapLongWord ((double *) (var->Data) + i); break;
default: break;
}
}
return (MFContinue);
}
int main(int argc, char *argv[]) {
int argPos, argNum = argc, ret, verbose = false;
char *tableName = DBrNItems;
char *nameSTR = (char *) NULL;
char *xcoordSTR = (char *) "XCoord";
char *ycoordSTR = (char *) "YCoord";
char *title = (char *) NULL, *subject = (char *) NULL;
char *domain = (char *) NULL, *version = (char *) NULL;
DBObjData *data, *pntData;
DBObjTable *table;
DBCoordinate coord;
DBObjTableField *nField, *xField, *yField, *tblFLD, *pntFLD;
DBObjRecord *tblRec, *pntRec, *symRec;
DBObjTable *pntTable;
DBObjTable *symbols;
DBObjTableField *symbolIDFLD;
DBObjTableField *fgFLD;
DBObjTableField *bgFLD;
DBObjTableField *stFLD;
DBObjTableField *coordFLD;
DBObjTableField *symbolFLD;
DBRegion extent;
for (argPos = 1; argPos < argNum;) {
if (CMargTest (argv[argPos], "-a", "--table")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing table name!");
return (CMfailed);
}
tableName = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-n", "--name")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing next field name!");
return (CMfailed);
}
nameSTR = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-x", "--xcoord")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing source field name!");
return (CMfailed);
}
xcoordSTR = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-y", "--ycoord")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing target field name!");
return (CMfailed);
}
ycoordSTR = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-t", "--title")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing title!");
return (CMfailed);
}
title = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-u", "--subject")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing subject!");
return (CMfailed);
}
subject = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-d", "--domain")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing domain!");
return (CMfailed);
}
domain = argv[argPos];
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-V", "--verbose")) {
verbose = true;
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
if (CMargTest (argv[argPos], "-h", "--help")) {
CMmsgPrint(CMmsgInfo, "%s [options] <input file> <output file>", CMfileName(argv[0]));
CMmsgPrint(CMmsgInfo, " -a,--table [table name]");
CMmsgPrint(CMmsgInfo, " -n,--name [name field]");
CMmsgPrint(CMmsgInfo, " -x,--xcoord [xcoord field]");
CMmsgPrint(CMmsgInfo, " -y,--ycoord [ycoord field]");
CMmsgPrint(CMmsgInfo, " -t,--title [dataset title]");
CMmsgPrint(CMmsgInfo, " -u,--subject [subject]");
CMmsgPrint(CMmsgInfo, " -d,--domain [domain]");
CMmsgPrint(CMmsgInfo, " -V,--verbose");
CMmsgPrint(CMmsgInfo, " -h,--help");
return (DBSuccess);
}
if ((argv[argPos][0] == '-') && ((int) strlen(argv[argPos]) > 1)) {
CMmsgPrint(CMmsgUsrError, "Unknown option: %s!", argv[argPos]);
return (CMfailed);
}
argPos++;
}
if (tableName == (char *) NULL) tableName = DBrNItems;
if (argNum > 3) {
CMmsgPrint(CMmsgUsrError, "Extra arguments!");
return (CMfailed);
}
if (verbose) RGlibPauseOpen(argv[0]);
data = new DBObjData();
if (((argNum > 1) && (strcmp(argv[1], "-") != 0) ? data->Read(argv[1]) : data->Read(stdin)) == DBFault) {
delete data;
if (argNum > 1) printf("File error in: %s", argv[1]);
return (DBFault);
}
if ((table = data->Table(tableName)) == (DBObjTable *) NULL) {
CMmsgPrint(CMmsgUsrError, "Invalid table!");
delete data;
return (CMfailed);
}
if (nameSTR == (char *) NULL) nField = (DBObjTableField *) NULL;
else if ((nField = table->Field(nameSTR)) == ((DBObjTableField *) NULL)) {
CMmsgPrint(CMmsgUsrError, "Name field!");
delete data;
return (CMfailed);
}
if ((xField = table->Field(xcoordSTR)) == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "XCoord field!");
delete data;
return (CMfailed);
}
if ((yField = table->Field(ycoordSTR)) == (DBObjTableField *) NULL) {
CMmsgPrint(CMmsgUsrError, "YCoord field!");
delete data;
return (CMfailed);
}
pntData = new DBObjData("", DBTypeVectorPoint);
if (title == (char *) NULL) title = (char *) "Converted Point coverage";
if (subject == (char *) NULL) subject = (char *) "Points";
if (domain == (char *) NULL) domain = data->Document(DBDocGeoDomain);
if (version == (char *) NULL) version = (char *) "0.01pre";
pntData->Name(title);
pntData->Document(DBDocSubject, subject);
pntData->Document(DBDocGeoDomain, domain);
pntData->Document(DBDocVersion, version);
pntTable = pntData->Table(DBrNItems);
symbols = pntData->Table(DBrNSymbols);
symbolIDFLD = symbols->Field(DBrNSymbolID);
fgFLD = symbols->Field(DBrNForeground);
bgFLD = symbols->Field(DBrNBackground);
stFLD = symbols->Field(DBrNStyle);
coordFLD = pntTable->Field(DBrNCoord);
symbolFLD = pntTable->Field(DBrNSymbol);
symRec = symbols->Add("Default Symbol");
symbolIDFLD->Int(symRec, 0);
fgFLD->Int(symRec, 1);
bgFLD->Int(symRec, 2);
stFLD->Int(symRec, 0);
for (tblRec = table->First(); tblRec != (DBObjRecord *) NULL; tblRec = table->Next()) {
if (CMmathEqualValues(coord.X = xField->Float(tblRec), xField->FloatNoData())) continue;
if (CMmathEqualValues(coord.Y = yField->Float(tblRec), yField->FloatNoData())) continue;
if (nField == (DBObjTableField *) NULL) pntRec = pntTable->Add(tblRec->Name());
else pntRec = pntTable->Add(nField->String(tblRec));
coordFLD->Coordinate(pntRec, coord);
symbolFLD->Record(pntRec, symRec);
extent.Expand(coord);
}
pntData->Extent(extent);
pntData->Projection(DBMathGuessProjection(extent));
pntData->Precision(DBMathGuessPrecision(extent));
for (tblFLD = table->Fields()->First(); tblFLD != (DBObjTableField *) NULL; tblFLD = table->Fields()->Next())
if ((tblFLD != nField) && (tblFLD != xField) && (tblFLD != yField) && DBTableFieldIsVisible(tblFLD)) {
pntTable->AddField(pntFLD = new DBObjTableField(*tblFLD));
pntFLD->Required(false);
pntRec = pntTable->First();
for (tblRec = table->First(); tblRec != (DBObjRecord *) NULL; tblRec = table->Next()) {
if (CMmathEqualValues(coord.X = xField->Float(tblRec), xField->FloatNoData())) continue;
if (CMmathEqualValues(coord.Y = yField->Float(tblRec), yField->FloatNoData())) continue;
switch (tblFLD->Type()) {
case DBTableFieldString:
pntFLD->String(pntRec, tblFLD->String(tblRec));
break;
case DBTableFieldInt:
pntFLD->Int(pntRec, tblFLD->Int(tblRec));
break;
case DBTableFieldFloat:
pntFLD->Float(pntRec, tblFLD->Float(tblRec));
break;
case DBTableFieldDate:
pntFLD->Date(pntRec, tblFLD->Date(tblRec));
break;
default:
CMmsgPrint(CMmsgAppError, "Invalid Field Type in: %s %d", __FILE__, __LINE__);
break;
}
pntRec = pntTable->Next();
}
}
ret = (argNum > 2) && (strcmp(argv[2], "-") != 0) ? pntData->Write(argv[2]) : pntData->Write(stdout);
delete data;
delete pntData;
if (verbose) RGlibPauseClose();
return (ret);
}
void RGISToolsConvertToPointCBK (Widget widget,RGISWorkspace *workspace,XmAnyCallbackStruct *callData)
{
char *nText, *xText, *yText, *selection;
int allowOk;
static int convert;
DBDataset *dataset = UIDataset ();
DBObjData *dbData = dataset->Data ();
DBObjTable *itemTable;
static Widget tableSelect = (Widget) NULL;
static Widget dShell = (Widget) NULL, mainForm;
static Widget nameTextF, xCoordTextF, yCoordTextF;
XmString string;
if (tableSelect == (Widget) NULL) tableSelect = UISelectionCreate ((char *) "Table Selection");
selection = UISelectObject (tableSelect,(DBObjectLIST<DBObject> *) dbData->Tables ());
if (selection == (char *) NULL) return;
if ((itemTable = dbData->Table (selection)) == (DBObjTable *) NULL)
{ CMmsgPrint (CMmsgAppError, "Invalid Table in: %s %d",__FILE__,__LINE__); return; }
_RGISToolsConvertToPointFields = itemTable->Fields ();
if (dShell == (Widget) NULL)
{
Widget button;
dShell = UIDialogForm ((char *) "Convert Table To Point",false);
mainForm = UIDialogFormGetMainForm (dShell);
string = XmStringCreate ((char *) "Select",UICharSetBold);
button = XtVaCreateManagedWidget ("RGISToolsConvertToPointNameButton",xmPushButtonWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNmarginHeight, 5,
XmNtraversalOn, False,
XmNlabelString, string,
XmNuserData, DBTableFieldIsString,
NULL);
XmStringFree (string);
nameTextF = XtVaCreateManagedWidget ("RGISToolsConvertToPointNameTextF",xmTextFieldWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, button,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNmaxLength, DBStringLength,
XmNcolumns, DBStringLength / 2,
NULL);
XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _RGISToolsConvertToPointSelectCBK,nameTextF);
string = XmStringCreate ((char *) "Name Field:",UICharSetBold);
XtVaCreateManagedWidget ("RGISToolsConvertToPointNameLabel",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, nameTextF,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNlabelString, string,
NULL);
XmStringFree (string);
string = XmStringCreate ((char *) "Select",UICharSetBold);
button = XtVaCreateManagedWidget ("RGISToolsConvertToPointXCoordButton",xmPushButtonWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, button,
XmNtopOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNmarginHeight, 5,
XmNtraversalOn, False,
XmNlabelString, string,
XmNuserData, DBTableFieldIsNumeric,
NULL);
XmStringFree (string);
xCoordTextF = XtVaCreateManagedWidget ("RGISToolsConvertToPointXCoordTextF",xmTextFieldWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, button,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNmaxLength, DBStringLength,
XmNcolumns, DBStringLength / 2,
NULL);
XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _RGISToolsConvertToPointSelectCBK,xCoordTextF);
string = XmStringCreate ((char *) "X Coordinate:",UICharSetBold);
XtVaCreateManagedWidget ("RGISToolsConvertToPointXCoordLabel",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, nameTextF,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNlabelString, string,
NULL);
XmStringFree (string);
string = XmStringCreate ((char *) "Select",UICharSetBold);
button = XtVaCreateManagedWidget ("RGISToolsConvertToPointYCoordButton",xmPushButtonWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, button,
XmNtopOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 10,
XmNmarginHeight, 5,
XmNtraversalOn, False,
XmNlabelString, string,
XmNuserData, DBTableFieldIsNumeric,
NULL);
XmStringFree (string);
yCoordTextF = XtVaCreateManagedWidget ("RGISToolsConvertToPointYCoordTextF",xmTextFieldWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, button,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNmaxLength, DBStringLength,
XmNcolumns, DBStringLength / 2,
NULL);
XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) _RGISToolsConvertToPointSelectCBK,yCoordTextF);
string = XmStringCreate ((char *) "Y Coordinate:",UICharSetBold);
XtVaCreateManagedWidget ("RGISToolsConvertToPointYCoordLabel",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, nameTextF,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNlabelString, string,
NULL);
XmStringFree (string);
XtAddCallback (UIDialogFormGetOkButton (dShell),XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&convert);
}
convert = false;
UIDialogFormPopup (dShell);
while (UILoop ())
{
xText = XmTextFieldGetString (xCoordTextF);
yText = XmTextFieldGetString (yCoordTextF);
allowOk = (strlen (xText) > 0) && (strlen (yText) > 0);
XtFree (xText); XtFree (yText);
XtSetSensitive (UIDialogFormGetOkButton (dShell),allowOk);
}
UIDialogFormPopdown (dShell);
if (convert)
{
DBObjData *pntData = new DBObjData ("",DBTypeVectorPoint);
pntData->Name (dbData->Name ());
pntData->Document (DBDocSubject,dbData->Document (DBDocSubject));
pntData->Document (DBDocGeoDomain,dbData->Document (DBDocGeoDomain));
if (UIDataHeaderForm (pntData))
{
DBCoordinate coord;
DBObjTableField *nField, *xField, *yField, *tblFLD, *pntFLD;
DBObjRecord *tblRec, *pntRec, *symRec;
DBObjTable *pntTable = pntData->Table (DBrNItems);
DBObjTable *symbols = pntData->Table (DBrNSymbols);
DBObjTableField *symbolIDFLD = symbols->Field (DBrNSymbolID);
DBObjTableField *fgFLD = symbols->Field (DBrNForeground);
DBObjTableField *bgFLD = symbols->Field (DBrNBackground);
DBObjTableField *stFLD = symbols->Field (DBrNStyle);
DBObjTableField *coordFLD = pntTable->Field (DBrNCoord);
DBObjTableField *symbolFLD = pntTable->Field (DBrNSymbol);
DBRegion extent;
symRec = symbols->Add ("Default Symbol");
symbolIDFLD->Int (symRec,0);
fgFLD->Int (symRec,1);
bgFLD->Int (symRec,2);
stFLD->Int (symRec,0);
nText = XmTextFieldGetString (nameTextF);
xText = XmTextFieldGetString (xCoordTextF);
yText = XmTextFieldGetString (yCoordTextF);
nField = _RGISToolsConvertToPointFields->Item (nText);
xField = _RGISToolsConvertToPointFields->Item (xText);
yField = _RGISToolsConvertToPointFields->Item (yText);
XtFree (nText); XtFree (xText); XtFree (yText);
for (tblRec = itemTable->First ();tblRec != (DBObjRecord *) NULL;tblRec = itemTable->Next ())
{
if (CMmathEqualValues (coord.X = xField->Float (tblRec),xField->FloatNoData ())) continue;
if (CMmathEqualValues (coord.Y = yField->Float (tblRec),yField->FloatNoData ())) continue;
if (nField == (DBObjTableField *) NULL) pntRec = pntTable->Add (tblRec->Name ());
else pntRec = pntTable->Add (nField->String (tblRec));
coordFLD->Coordinate (pntRec,coord);
symbolFLD->Record (pntRec,symRec);
extent.Expand (coord);
}
pntData->Extent (extent);
pntData->Projection (DBMathGuessProjection (extent));
pntData->Precision (DBMathGuessPrecision (extent));
for (tblFLD = _RGISToolsConvertToPointFields->First ();tblFLD != (DBObjTableField *) NULL;tblFLD = _RGISToolsConvertToPointFields->Next ())
if ((tblFLD != nField) && (tblFLD != xField) && (tblFLD != yField) && DBTableFieldIsVisible (tblFLD))
{
pntTable->AddField (pntFLD = new DBObjTableField (*tblFLD));
pntFLD->Required (false);
pntRec = pntTable->First ();
for (tblRec = itemTable->First ();tblRec != (DBObjRecord *) NULL;tblRec = itemTable->Next ())
{
if (CMmathEqualValues (coord.X = xField->Float (tblRec),xField->FloatNoData ())) continue;
if (CMmathEqualValues (coord.Y = yField->Float (tblRec),yField->FloatNoData ())) continue;
switch (tblFLD->Type ())
{
case DBTableFieldString: pntFLD->String (pntRec,tblFLD->String (tblRec)); break;
case DBTableFieldInt: pntFLD->Int (pntRec,tblFLD->Int (tblRec)); break;
case DBTableFieldFloat: pntFLD->Float (pntRec,tblFLD->Float (tblRec)); break;
case DBTableFieldDate: pntFLD->Date (pntRec,tblFLD->Date (tblRec)); break;
default: CMmsgPrint (CMmsgAppError, "Invalid Field Type in: %s %d",__FILE__,__LINE__); break;
}
pntRec = pntTable->Next ();
}
}
workspace->CurrentData (pntData);
}
else delete pntData;
}
}
DBInt DBMathExpression::Int(DBObjRecord *record) {
if (OperVAR == DBMathOperatorArgs) return (DBDefaultMissingIntVal);
if (OperVAR == DBMathOperatorFunc) {
DBInt var;
int (*func)(int) = (int (*)(int)) RightPTR;
return ((var = LeftPTR->Int(record)) == DBDefaultMissingIntVal ?
DBDefaultMissingIntVal : ((DBInt) ((*func)(var))));
}
if (OperVAR == DBMathOperatorCond) { return (((DBMathExpression *) RightPTR)->Int(record, LeftPTR->Int(record))); }
switch (TypeVAR) {
case DBVariableString: {
char *lVar, *rVar;
DBInt comp;
lVar = LeftPTR->String(record);
rVar = RightPTR->String(record);
if ((lVar == (char *) NULL) || (rVar == (char *) NULL)) return (DBDefaultMissingIntVal);
comp = strcmp(lVar, rVar);
switch (OperVAR) {
case (DBMathOperatorGrt):
return (comp > 0 ? true : false);
case (DBMathOperatorGrt | DBMathOperatorEqu):
return (comp >= 0 ? true : false);
case (DBMathOperatorEqu):
return (comp == 0 ? true : false);
case (DBMathOperatorSml | DBMathOperatorGrt):
return (comp != 0 ? true : false);
case (DBMathOperatorSml | DBMathOperatorEqu):
return (comp <= 0 ? true : false);
case (DBMathOperatorSml):
return (comp < 0 ? true : false);
default:
break;
}
}
break;
case DBVariableInt: {
DBInt lVar, rVar;
lVar = LeftPTR->Int(record);
rVar = RightPTR->Int(record);
if ((OperVAR != DBMathOperatorEqu) && (OperVAR != (DBMathOperatorSml | DBMathOperatorGrt)) &&
((lVar == DBDefaultMissingIntVal) || (rVar == DBDefaultMissingIntVal)))
return (DBDefaultMissingIntVal);
switch (OperVAR) {
case (DBMathOperatorOr):
return (lVar || rVar);
case (DBMathOperatorAnd):
return (lVar && rVar);
case (DBMathOperatorGrt):
return (lVar > rVar ? true : false);
case (DBMathOperatorGrt | DBMathOperatorEqu):
return (lVar >= rVar ? true : false);
case (DBMathOperatorEqu):
return (lVar == rVar ? true : false);
case (DBMathOperatorSml | DBMathOperatorGrt):
return (lVar != rVar ? true : false);
case (DBMathOperatorSml | DBMathOperatorEqu):
return (lVar <= rVar ? true : false);
case (DBMathOperatorSml):
return (lVar < rVar ? true : false);
case (DBMathOperatorAdd):
return (lVar + rVar);
case (DBMathOperatorSub):
return (lVar - rVar);
case (DBMathOperatorMul):
return (lVar * rVar);
case (DBMathOperatorMod):
return (lVar % rVar);
case (DBMathOperatorDiv):
return (lVar / rVar);
case (DBMathOperatorExp):
return ((DBInt) (pow((double) lVar, (double) rVar)));
default:
break;
}
}
break;
case DBVariableFloat: {
DBFloat lVar, rVar;
lVar = LeftPTR->Float(record);
rVar = RightPTR->Float(record);
if ((OperVAR != DBMathOperatorEqu) && (OperVAR != (DBMathOperatorSml | DBMathOperatorGrt)) &&
((CMmathEqualValues(lVar, DBDefaultMissingFloatVal) ||
CMmathEqualValues(rVar, DBDefaultMissingFloatVal))))
return (DBDefaultMissingIntVal);
switch (OperVAR) {
case (DBMathOperatorGrt):
return (lVar > rVar ? true : false);
case (DBMathOperatorGrt | DBMathOperatorEqu):
return (lVar >= rVar ? true : false);
case (DBMathOperatorEqu):
return (CMmathEqualValues(lVar, rVar));
case (DBMathOperatorSml | DBMathOperatorGrt):
return (!CMmathEqualValues(lVar, rVar));
case (DBMathOperatorSml | DBMathOperatorEqu):
return (lVar <= rVar ? true : false);
case (DBMathOperatorSml):
return (lVar < rVar ? true : false);
case (DBMathOperatorAdd):
return ((DBInt) (lVar + rVar));
case (DBMathOperatorSub):
return ((DBInt) (lVar - rVar));
case (DBMathOperatorMul):
return ((DBInt) (lVar * rVar));
case (DBMathOperatorMod):
return ((DBInt) (fmod(lVar, rVar)));
case (DBMathOperatorDiv):
return ((DBInt) (lVar / rVar));
case (DBMathOperatorExp):
return ((DBInt) (pow(lVar, rVar)));
default:
break;
}
}
break;
}
return (DBDefaultMissingIntVal);
}
void RGISAnGNUXYPlotCBK (Widget widget,RGISWorkspace *workspace,XmAnyCallbackStruct *callData)
{
FILE *file;
char command [DBDataFileNameLen * 2 + DBStringLength];
const char *ghaasDir;
char *f0Text, *f1Text, fileName [12];
int allowOk, fd;
static int plot = false, logScale = false;
DBDataset *dataset = UIDataset ();
DBObjData *dbData = dataset->Data ();
DBObjTable *itemTable = dbData->Table (DBrNItems);
static Widget dShell = (Widget) NULL, mainForm;
static Widget field0TextF, field1TextF;
Widget toggle;
XmString string;
if (dShell == (Widget) NULL)
{
Widget button;
dShell = UIDialogForm ((char *) "Compare Fields",false);
mainForm = UIDialogFormGetMainForm (dShell);
string = XmStringCreate ((char *) "Select",UICharSetBold);
button = XtVaCreateManagedWidget ("RGISEdiCompFieldsButton",xmPushButtonWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNmarginHeight, 5,
XmNtraversalOn, False,
XmNlabelString, string,
XmNuserData, DBTableFieldIsNumeric,
NULL);
XmStringFree (string);
field0TextF = XtVaCreateManagedWidget ("RGISEditCompField0TextF",xmTextFieldWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, button,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNmaxLength, DBStringLength,
XmNcolumns, DBStringLength / 2,
NULL);
XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxObjectSelectCBK,field0TextF);
string = XmStringCreate ((char *) "X Field:",UICharSetBold);
XtVaCreateManagedWidget ("RGISEditCompFieldNameLabel",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, field0TextF,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNlabelString, string,
NULL);
XmStringFree (string);
string = XmStringCreate ((char *) "Select",UICharSetBold);
button = XtVaCreateManagedWidget ("RGISEditCompField0Button",xmPushButtonWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, button,
XmNtopOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNmarginHeight, 5,
XmNtraversalOn, False,
XmNlabelString, string,
XmNuserData, DBTableFieldIsNumeric,
NULL);
XmStringFree (string);
field1TextF = XtVaCreateManagedWidget ("RGISEditCompField1TextF",xmTextFieldWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, button,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNmaxLength, DBStringLength,
XmNcolumns, DBStringLength / 2,
NULL);
XtAddCallback (button,XmNactivateCallback,(XtCallbackProc) UIAuxObjectSelectCBK,field1TextF);
string = XmStringCreate ((char *) "Y Field:",UICharSetBold);
XtVaCreateManagedWidget ("RGISEditCompField1Label",xmLabelWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, button,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, field1TextF,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, button,
XmNlabelString, string,
NULL);
XmStringFree (string);
string = XmStringCreate ((char *) "Logarithmic Scale",UICharSetBold);
toggle = XtVaCreateManagedWidget ("RGISEditCompLogScaleToggle",xmToggleButtonWidgetClass,mainForm,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, button,
XmNtopOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 10,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 10,
XmNlabelString, string,
XmNhighlightThickness, 0,
XmNshadowThickness, 0,
XmNmarginWidth, 5,
XmNset, False,
NULL);
XmStringFree (string);
XtAddCallback (toggle,XmNvalueChangedCallback,(XtCallbackProc) UIAuxSetToggleCBK, (XtPointer) &logScale);
XtAddCallback (UIDialogFormGetOkButton (dShell),XmNactivateCallback,(XtCallbackProc) UIAuxSetBooleanTrueCBK,&plot);
}
plot = false;
XtVaSetValues (field0TextF,XmNuserData, itemTable->Fields (), NULL);
XtVaSetValues (field1TextF,XmNuserData, itemTable->Fields (), NULL);
UIDialogFormPopup (dShell);
while (UILoop ())
{
f0Text = XmTextFieldGetString (field0TextF);
f1Text = XmTextFieldGetString (field1TextF);
allowOk = (strlen (f0Text) > 0) && (strlen (f1Text) > 0);
XtFree (f0Text); XtFree (f1Text);
XtSetSensitive (UIDialogFormGetOkButton (dShell),allowOk);
}
UIDialogFormPopdown (dShell);
if (plot)
{
char buffer [256];
DBInt intVal, rowID;
DBFloat val;
DBObjTableField *field0 = itemTable->Field (f0Text = XmTextFieldGetString (field0TextF));
DBObjTableField *field1 = itemTable->Field (f1Text = XmTextFieldGetString (field1TextF));
DBObjRecord *record;
XtFree (f0Text); XtFree (f1Text);
if ((field0 == (DBObjTableField *) NULL) || (field1 == (DBObjTableField *) NULL))
{ CMmsgPrint (CMmsgAppError, "Invalid Compare Fields in: %s %d",__FILE__,__LINE__); return; }
strcpy (fileName,"ghaasXXXXXX");
if ((fd = mkstemp (fileName)) == DBFault)
{ CMmsgPrint (CMmsgSysError, "File Opening Error in: %s %d",__FILE__,__LINE__); return; }
if ((file = fdopen (fd,"w")) == (FILE *) NULL)
{ CMmsgPrint (CMmsgSysError, "File Opening Error in: %s %d",__FILE__,__LINE__); return; }
fprintf (file,"\"GHAASId\"\t\"RecordName\"\t\"Selected\"\t\"%s\"\t\"%s\"\n",field0->Name (),field1->Name ());
for (rowID = 0;rowID < itemTable->ItemNum ();++rowID)
{
record = itemTable->Item (rowID);
if ((record->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle) continue;
sprintf (buffer,"%d\t\"%s\"\t%d",record->RowID () + 1,record->Name (),
(record->Flags () & DBObjectFlagSelected) == DBObjectFlagSelected ? true : false);
if (field0->Type () == DBTableFieldInt)
{
intVal = field0->Int (record);
if (intVal == field0->IntNoData ()) continue;
sprintf (buffer + strlen (buffer),"\t%d",intVal);
}
else
{
val = field0->Float (record);
if (CMmathEqualValues (val,field0->FloatNoData ())) continue;
sprintf (buffer + strlen (buffer),"\t%f",val);
}
if (field1->Type () == DBTableFieldInt)
{
intVal = field1->Int (record);
if (intVal == field1->IntNoData ()) continue;
sprintf (buffer + strlen (buffer),"\t%d",intVal);
}
else
{
val = field1->Float (record);
if (CMmathEqualValues (val,field1->FloatNoData ())) continue;
sprintf (buffer + strlen (buffer),"\t%f",val);
}
fprintf (file,"%s\n",buffer);
}
fclose (file);
ghaasDir = getenv ("GHAAS_DIR");
sprintf (command,"%s/Scripts/xy-plot.sh %s %s",ghaasDir != (const char *) NULL ? ghaasDir : ".",fileName,logScale ? "log" : "normal");
system (command);
unlink (fileName);
}
}
int main(int argc, char *argv[]) {
int argPos = 0, argNum = argc, ret = CMfailed, itemSize, itemID;
FILE *inFile = stdin, *outFile = stdout;
void *items = (void *) NULL;
MFVarHeader_t header;
if (argNum < 2) goto Help;
for (argPos = 1; argPos < argNum;) {
if (CMargTest(argv[argPos], "-i", "--item")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) {
CMmsgPrint(CMmsgUsrError, "Missing sampling item!");
return (CMfailed);
}
if ((sscanf(argv[argPos], "%d", &itemID)) != 1) {
CMmsgPrint(CMmsgUsrError, "Invalid sampling item");
return (CMfailed);
}
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) <= argPos) break;
continue;
}
Help:
if (CMargTest(argv[argPos], "-h", "--help")) {
if ((argNum = CMargShiftLeft(argPos, argv, argNum)) < argPos) break;
CMmsgPrint(CMmsgUsrError, "%s [options] <in datastream> <out datastream>", CMfileName(argv[0]));
CMmsgPrint(CMmsgUsrError, " -i, --item [item]");
CMmsgPrint(CMmsgUsrError, " -h,--help");
ret = CMsucceeded;
goto Stop;
}
if ((argv[argPos][0] == '-') && (strlen(argv[argPos]) > 1)) {
CMmsgPrint(CMmsgUsrError, "Unknown option: %s!", argv[argPos]);
return (CMfailed);
}
argPos++;
}
if (argNum > 3) {
CMmsgPrint(CMmsgUsrError, "Extra arguments!");
goto Stop;
}
if ((inFile = (argNum > 1) && (strcmp(argv[1], "-") != 0) ? fopen(argv[1], "r") : stdin) == (FILE *) NULL) {
CMmsgPrint(CMmsgSysError, "Input file opening error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
if ((outFile = (argNum > 2) && (strcmp(argv[2], "-") != 0) ? fopen(argv[2], "w") : stdout) == (FILE *) NULL) {
CMmsgPrint(CMmsgSysError, "Output file opening error in: %s %d", __FILE__, __LINE__);
goto Stop;
}
while (MFVarReadHeader(&header, inFile)) {
if (items == (void *) NULL) {
itemSize = MFVarItemSize(header.DataType);
if ((items = (void *) calloc(header.ItemNum, itemSize)) == (void *) NULL) {
CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
}
if ((int) fread(items, itemSize, header.ItemNum, inFile) != header.ItemNum) {
CMmsgPrint(CMmsgSysError, "Input reading error in: %s:%d", __FILE__, __LINE__);
goto Stop;
}
if ((itemID < 0) || (itemID >= header.ItemNum)) {
CMmsgPrint(CMmsgAppError, "Invalid Item id [%d]", itemID);
continue;
}
switch (header.DataType) {
case MFByte:
if (((char *) items)[itemID] != header.Missing.Int)
fprintf(outFile, "%s\t%d\n", header.Date, (int) ((char *) items)[itemID]);
else
fprintf(outFile, "%s\t\n", header.Date);
break;
case MFShort:
if (header.Swap != 1) MFSwapHalfWord(((short *) items) + itemID);
if (((short *) items)[itemID] != header.Missing.Int)
fprintf(outFile, "\t%d\n", (int) ((short *) items)[itemID]);
else
fprintf(outFile, "%s\t\n", header.Date);
break;
case MFInt:
if (header.Swap != 1) MFSwapWord(((int *) items) + itemID);
if (((int *) items)[itemID] != header.Missing.Int)
fprintf(outFile, "%s\t%d\n", header.Date, (int) ((int *) items)[itemID]);
else
fprintf(outFile, "%s\t\n", header.Date);
break;
case MFFloat:
if (header.Swap != 1) MFSwapWord(((float *) items) + itemID);
if (CMmathEqualValues(((float *) items)[itemID], header.Missing.Float) == false)
fprintf(outFile, "%s\t%f\n", header.Date, (float) ((float *) items)[itemID]);
else
fprintf(outFile, "%s\t\n", header.Date);
break;
case MFDouble:
if (header.Swap != 1) MFSwapLongWord(((double *) items) + itemID);
if (CMmathEqualValues(((double *) items)[itemID], header.Missing.Float) == false)
fprintf(outFile, "%s\t%lf\n", header.Date, (double) ((double *) items)[itemID]);
else
fprintf(outFile, "%s\t\n", header.Date);
break;
}
}
ret = CMsucceeded;
Stop:
if (inFile != stdin) fclose(inFile);
if (outFile != stdout) fclose(outFile);
return (ret);
}
static void _RGISToolsExportNetworkCBK (Widget widget,RGISWorkspace *workspace,XmAnyCallbackStruct *callData)
{
char *selection;
FILE *outFILE;
DBInt cellID, fieldID, fieldNum = 0;
DBCoordinate coord;
DBObjRecord *cellRec,*toCellRec, *basinRec;
DBDataset *dataset = UIDataset ();
DBObjData *netData = dataset->Data ();
DBNetworkIF *netIF = new DBNetworkIF (netData);
DBObjTable *cellTable = netData->Table (DBrNCells);
DBObjTableField *field, **fields = (DBObjTableField **) NULL;
static Widget dirSelect = NULL;
widget = widget; workspace = workspace; callData = callData;
if (dirSelect == NULL)
{ if ((dirSelect = UIFileSelectionCreate ((char *) "Network File",NULL,(char *) "*.txt",XmFILE_REGULAR)) == NULL) return; }
if ((selection = UIFileSelection (dirSelect,False)) == NULL) return;
if ((outFILE = fopen (selection,"w")) == (FILE *) NULL)
{ CMmsgPrint (CMmsgSysError, "File Opening Error in: %s %d",__FILE__,__LINE__); return; }
fprintf (outFILE,"\"CellID\"\t\"XCoord\"\t\"YCoord\"\t\"BasinID\"\t\"ToCell\"\t\"CellArea\"\t\"CellLength\"");
for (fieldID = 0;fieldID < cellTable->FieldNum (); fieldID++)
{
if ((field = cellTable->Field (fieldID)) == (DBObjTableField *) NULL)
{
if (fields != (DBObjTableField **) NULL) free (fields);
CMmsgPrint (CMmsgSysError, "Invalid field in: %s %d",__FILE__,__LINE__);
return;
}
if (field->Required ()) continue;
if ((fields = (DBObjTableField **) realloc (fields,(fieldNum + 1) * sizeof (DBObjTableField *))) == (DBObjTableField **) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return; }
fields [fieldNum] = field;
fprintf (outFILE,"\t\"%s\"",field->Name ());
fieldNum++;
}
fprintf (outFILE,"\n");
for (cellID = 0;cellID < netIF->CellNum (); cellID++)
{
cellRec = netIF->Cell (cellID);
coord = netIF->Center (cellRec);
basinRec = netIF->Basin (cellRec);
toCellRec = netIF->ToCell (cellRec);
fprintf (outFILE,"%d\t%f\t%f\t%d\t%d\t%f\t%f",cellRec->RowID () + 1,
coord.X, coord.Y,
basinRec->RowID () + 1,
toCellRec == (DBObjRecord *) NULL ? DBFault : toCellRec->RowID () + 1,
netIF->CellArea (cellRec),
netIF->CellLength (cellRec));
for (fieldID = 0;fieldID < fieldNum; fieldID++)
switch (fields [fieldID]->Type ())
{
default:
case DBTableFieldString: fprintf (outFILE,"%c\"%s\"",DBASCIISeparator,fields [fieldID]->String (cellRec)); break;
case DBTableFieldInt:
if (fields [fieldID]->Int (cellRec) == fields [fieldID]->IntNoData ())
fprintf (outFILE,"%c",DBASCIISeparator);
else fprintf (outFILE,"%c%d",DBASCIISeparator,fields [fieldID]->Int (cellRec));
break;
case DBTableFieldFloat:
if (CMmathEqualValues (fields [fieldID]->Float (cellRec),fields [fieldID]->FloatNoData ()))
fprintf (outFILE,"%c",DBASCIISeparator);
else fprintf (outFILE,"%c%f",DBASCIISeparator,fields [fieldID]->Float (cellRec));
break;
case DBTableFieldDate: fprintf (outFILE,"%c\"%s\"",DBASCIISeparator,fields [fieldID]->String(cellRec)); break;
}
fprintf (outFILE,"\n");
}
fclose (outFILE);
}
