//--------------------------------------------------------- bool CWKSP_Project::_Save_Data(CSG_MetaData &Entry, const wxString &ProjectDir, CSG_Data_Object *pDataObject, CSG_Parameters *pParameters) { if( !pDataObject || !pDataObject->Get_File_Name(false) || SG_STR_LEN(pDataObject->Get_File_Name(false)) == 0 ) { return( false ); } CSG_MetaData *pEntry = Entry.Add_Child("DATASET"); switch( pDataObject->Get_ObjectType() ) { default: return( false ); case SG_DATAOBJECT_TYPE_Grid : pEntry->Add_Property("type", "GRID" ); break; case SG_DATAOBJECT_TYPE_Grids : pEntry->Add_Property("type", "GRIDS" ); break; case SG_DATAOBJECT_TYPE_Table : pEntry->Add_Property("type", "TABLE" ); break; case SG_DATAOBJECT_TYPE_Shapes : pEntry->Add_Property("type", "SHAPES"); break; case SG_DATAOBJECT_TYPE_TIN : pEntry->Add_Property("type", "TIN" ); break; case SG_DATAOBJECT_TYPE_PointCloud: pEntry->Add_Property("type", "POINTS"); break; } if( wxFileExists(pDataObject->Get_File_Name(false)) ) { pEntry->Add_Child("FILE", SG_File_Get_Path_Relative(&ProjectDir, pDataObject->Get_File_Name(false))); } else if( pDataObject->Get_MetaData_DB().Get_Children_Count() > 0 ) { pEntry->Add_Child("FILE", pDataObject->Get_File_Name(false)); } else { return( false ); } if( pParameters ) { pParameters->DataObjects_Check(true); pParameters->Serialize(*pEntry->Add_Child("PARAMETERS"), true); //------------------------------------------------- pEntry = pEntry->Get_Child("PARAMETERS"); for(int i=0; i<pEntry->Get_Children_Count(); i++) { if( !pEntry->Get_Child(i)->Get_Name().CmpNoCase("DATA") ) { CSG_String File = pEntry->Get_Child(i)->Get_Content(); if( File.BeforeFirst(':').CmpNoCase("PGSQL") && SG_File_Exists(File) ) { pEntry->Get_Child(i)->Set_Content(SG_File_Get_Path_Relative(&ProjectDir, File.w_str())); } } } } return( true ); }
//--------------------------------------------------------- wxString Get_FilePath_Relative(const wxChar *Directory, const wxChar *FileName) { int i, n; if( Directory && FileName && (n = SG_STR_LEN(Directory)) < (int)SG_STR_LEN(FileName) ) { for(i=0; i<n; i++) { if( Directory[i] != FileName[i] ) { return( FileName ); } } return( FileName + n ); } return( FileName ); }
//--------------------------------------------------------- // int varying; Does the result of the function vary // even when the parameters stay the same? // varying = 1 for e.g. random - number generators. // Result: 0 is rendered if there is an error // 1 is rendered otherwise // int CSG_Formula::Add_Function(SG_Char *name, TSG_PFNC_Formula_1 f, int n_pars, int varying) { TSG_Formula_Item *where; if( n_pars < 0 || n_pars > 3 ) { _Set_Error(LNG("invalid number of parameters")); return( 0 ); } for(where=gSG_Functions; where->f != NULL && SG_STR_CMP(name, where->name); where++) { ; } if( where->f != NULL ) { where->f = f; where->varying = varying; where->n_pars = n_pars; /*old function is superseded */ _Set_Error(); return( 1 ); } else if( (where - gSG_Functions) >= MAX_CTABLE - 1 ) { _Set_Error(LNG("function table full")); return 0; } else { where->name =(SG_Char *)calloc(SG_STR_LEN(name) + 1, sizeof(SG_Char)); if( where->name == NULL ) { _Set_Error(LNG("no memory")); return( 0 ); } SG_STR_CPY(where->name, name); where->f = f; where->varying = varying; where->n_pars = n_pars; _Set_Error(); return( 1 ); } }
bool CFit::On_Execute(void) { int i, j, NrVars; vector < double> x, y, StartValue, Result; CSG_String msg; CSG_Parameters StartParameters; const SG_Char *formel = Parameters("FORMEL")->asString(); Formel.Add_Function(SG_T("NUG"), (TSG_PFNC_Formula_1) NUG, 1, 0); Formel.Add_Function(SG_T("SPH"), (TSG_PFNC_Formula_1) SPH, 2, 0); Formel.Add_Function(SG_T("EXP"), (TSG_PFNC_Formula_1) EXP, 2, 0); Formel.Add_Function(SG_T("LIN"), (TSG_PFNC_Formula_1) LIN, 2, 0); Formel.Set_Formula(formel); if (Formel.Get_Error(msg)) { Message_Add(msg); return false; } const SG_Char *uservars = NULL; uservars = Formel.Get_Used_Variables(); NrVars = 0; for (i = 0; i < SG_STR_LEN(uservars); i++) { if (uservars[i] >='a' && uservars[i] <= 'z') { if (uservars[i] != 'x') vars[NrVars++] = uservars[i]; } } vars[NrVars] =(char) 0; StartParameters.Add_Info_String(NULL, _TL(""), _TL("Formula"), _TL("Formula"), formel); for (i = 0; i < strlen(vars); i++) { CSG_String c(vars[i]); StartParameters.Add_Value(NULL, c, c, _TL("Start Value"), PARAMETER_TYPE_Double, 1.0); } Dlg_Parameters(&StartParameters, _TL("Start Values")); for (i = 0; i < strlen(vars); i++) { char c[3]; sprintf(c, "%c", vars[i]); StartValue.push_back(StartParameters(c)->asDouble()); } CSG_Table *pTable = Parameters("SOURCE")->asTable(); int Record_Count = pTable->Get_Record_Count(); int yField = Parameters("YFIELD")->asInt(); int xField = Parameters("XFIELD")->asInt(); bool Use_X = Parameters("USE_X")->asBool(); pTable->Add_Field(_TL("Fit") , SG_DATATYPE_Double); for (i = 0; i < Record_Count; i++) { CSG_Table_Record * Record = pTable->Get_Record(i); if (Use_X) { x.push_back(Record->asDouble(xField)); } else { x.push_back(i); } y.push_back(Record->asDouble(yField)); } TLMFit *Fit; Fit = new TLMFit(x, y, StartValue, FitFunc); int max_iter = Parameters("ITER")->asInt(); double Max_lamda = Parameters("LAMDA")->asInt(); int iter = 0; try { Fit->Fit(); while ((Fit->Alamda() < Max_lamda) &&(iter < max_iter) &&Process_Get_Okay(true)) { Fit->Fit(); iter++; } } catch (ESingularMatrix &E) { if (E.Type == 1 || E.Type == 2) { msg.Printf(_TL("Matrix signular\n")); Message_Add(msg); return false; } } Result = Fit->Param(); for (i = 0; i < NrVars; i++) { Formel.Set_Variable(vars[i], (double) Result[i]); } msg.Printf(_TL("Model Parameters:")); Message_Add(msg); for (i = 0; i < NrVars; i++) { msg.Printf(SG_T("%c = %f\n"), vars[i], Result[i]); Message_Add(msg); } msg.Printf(_TL("\nRMS of Residuals (stdfit):\t%f\n"), sqrt(Fit->Chisq()/x.size())); Message_Add(msg); msg.Printf(_TL("Correlation Matrix of the Fit Parameters:\n")); Message_Add(msg); vector< vector < double> > covar = Fit->Covar(); msg.Printf(_TL("")); for (j = 0; j < NrVars; j++) msg.Printf(SG_T("%s\t%c"), msg.c_str(), vars[j]); msg.Printf(SG_T("%s\n"), msg.c_str()); Message_Add(msg); for (i = 0; i < NrVars; i++) { msg.Printf(SG_T("%c"), vars[i]); for (j = 0; j <= i; j++) { msg.Printf(SG_T("%s\t%f"), msg.c_str(), covar[i][j]/covar[i][i]); } msg.Printf(SG_T("%s\n"), msg.c_str()); Message_Add(msg); } int Field_Count = pTable->Get_Field_Count(); for (i = 0; i < Record_Count; i++) { CSG_Table_Record * Record = pTable->Get_Record(i); Record->Set_Value(Field_Count - 1, Formel.Get_Value(x[i])); } // API_FREE (uservars); return (true); }
//--------------------------------------------------------- SG_Char *CSG_Formula::i_trans(SG_Char *function, SG_Char *begin, SG_Char *end) { int pars; SG_Char *scan; SG_Char *tempu, *temp3; SG_Char *temps = NULL; SG_Char tempch; double tempd; SG_Char *endf; int n_function; int space; int i; SG_Char *paramstr[MAX_PARMS]; SG_Char *par_buf; if (begin >= end) { _Set_Error(LNG("missing operand")); i_error = begin; return NULL; } for (pars = 0, scan = begin; scan < end && pars >= 0; scan++) { if (*scan == SG_T('(')) pars++; else if (*scan == SG_T(')')) pars--; } if (pars < 0 || pars > 0) { _Set_Error(LNG("unmatched parentheses")); i_error = scan - 1; return NULL; } for (pars = 0, scan = end - 1; scan >= begin; scan--) { if (*scan == SG_T('(')) pars++; else if (*scan == SG_T(')')) pars--; else if (!pars &&(*scan == SG_T('+') ||((*scan == SG_T('-')) && scan != begin)) &&(scan == begin || *(scan - 1) != SG_T('E'))) break; } if (scan >= begin) { if ((tempu = i_trans(function, begin, scan)) && (temp3 = i_trans(tempu, scan + 1, end))) { *temp3++ = *scan; temp3 = comp_time(function, temp3, 2); if( m_bError ) return NULL; else return temp3; } else return NULL; } for (pars = 0, scan = end - 1; scan >= begin; scan--) { if (*scan == SG_T('(')) pars++; else if (*scan == SG_T(')')) pars--; else if (!pars &&(*scan == SG_T('*') || *scan == SG_T('/'))) break; } if (scan >= begin) { if ((tempu = i_trans(function, begin, scan)) && (temp3 = i_trans(tempu, scan + 1, end))) { *temp3++ = *scan; temp3 = comp_time(function, temp3, 2); if (m_bError) return NULL; else return temp3; } else return NULL; } /* unary minus */ if (*begin == SG_T('-')) { tempu = i_trans(function, begin + 1, end); if (tempu) { *tempu++ = SG_T('M'); tempu = comp_time(function, tempu, 1); if (m_bError) return NULL; else return tempu; } else return NULL; } for (pars = 0, scan = end - 1; scan >= begin; scan--) { if (*scan == SG_T('(')) pars++; else if (*scan == SG_T(')')) pars--; else if (!pars &&(*scan == SG_T('^'))) break; else if (!pars &&(*scan == SG_T('='))) break; else if (!pars &&(*scan == SG_T('>'))) break; else if (!pars &&(*scan == SG_T('<'))) break; else if (!pars &&(*scan == SG_T('&'))) break; else if (!pars &&(*scan == SG_T('|'))) break; } if (scan >= begin) { if ((tempu = i_trans(function, begin, scan)) && (temp3 = i_trans(tempu, scan + 1, end))) { *temp3++ = *scan; temp3 = comp_time(function, temp3, 2); if (m_bError) return NULL; else return temp3; } else return NULL; } /* erase white space */ while (isspace(*begin)) begin++; while (isspace(*(end - 1))) end--; if (*begin == SG_T('(') && *(end - 1) == SG_T(')')) return i_trans(function, begin + 1, end - 1); if (end == begin + 1 && islower(*begin)) { *function++ = SG_T('V'); *function++ = *begin; return function; } tempch = *end; *end = SG_T('\0'); tempd = SG_STR_TOD(begin, (SG_Char**) &tempu); *end = tempch; if ((SG_Char*) tempu == end) { *function++ = SG_T('D'); if (i_pctable < MAX_CTABLE) { i_ctable[i_pctable] = tempd; *function++ =(SG_Char) i_pctable++; } else { _Set_Error(LNG("too many constants")); i_error = begin; return NULL; } return function; } /*function*/ if (!isalpha(*begin) && *begin != SG_T('_')) { _Set_Error(LNG("syntax error")); i_error = begin; return NULL; } for (endf = begin + 1; endf < end &&(isalnum(*endf) || *endf == SG_T('_')); endf++) ; tempch = *endf; *endf = SG_T('\0'); if ((n_function = _Get_Function(begin)) == -1) { *endf = tempch; i_error = begin; return NULL; } *endf = tempch; if (*endf != SG_T('(') || *(end - 1) != SG_T(')')) { _Set_Error(LNG("improper function syntax")); i_error = endf; return NULL; } if (gSG_Functions[n_function].n_pars == 0) { /*function without parameters(e.g. pi()) */ space = 1; for (scan = endf + 1; scan <(end - 1); scan++) if (!isspace(*scan)) space = 0; if (space) { *function++ = SG_T('F'); *function++ = n_function; function = comp_time(function - 2, function, 0); if (m_bError) return NULL; /* internal error in comp_time */ else return function; } else { i_error = endf + 1; _Set_Error(LNG("too many parameters")); return NULL; } } else { /*function with parameters*/ tempch = *(end - 1); *(end - 1) = SG_T('\0'); par_buf =(SG_Char *) SG_Malloc(sizeof(SG_Char) * (SG_STR_LEN(endf + 1) + 1)); if (!par_buf) { _Set_Error(LNG("no memory")); i_error = NULL; return NULL; } SG_STR_CPY(par_buf, endf + 1); *(end - 1) = tempch; for (i = 0; i < gSG_Functions[n_function].n_pars; i++) { if ((temps = my_strtok((i == 0) ? par_buf : NULL)) == NULL) break; paramstr[i] = temps; } if (temps == NULL) { SG_Free(par_buf); i_error = end - 2; _Set_Error(LNG("too few parameters")); return NULL; } if ((temps = my_strtok(NULL)) != NULL) { SG_Free(par_buf); i_error =(temps - par_buf) +(endf + 1); _Set_Error(LNG("too many parameters")); return NULL; } tempu = function; for (i = 0; i < gSG_Functions[n_function].n_pars; i++) if( !(tempu = i_trans(tempu, paramstr[i], paramstr[i] + SG_STR_LEN(paramstr[i]))) ) { i_error =(i_error - par_buf) +(endf + 1); SG_Free(par_buf); return NULL; } /* OK */ SG_Free(par_buf); *tempu++ = SG_T('F'); *tempu++ = n_function; tempu = comp_time(function, tempu, gSG_Functions[n_function].n_pars); if (m_bError) return NULL; /* internal error in comp_time */ else return tempu; } }
//--------------------------------------------------------- CSG_Formula::TMAT_Formula CSG_Formula::_Translate(const SG_Char *sourc, const SG_Char *args, int *leng, int *error) { SG_Char *result; SG_Char *source; const SG_Char *scan, *scarg; SG_Char *code; SG_Char *nfunc; size_t size_estim; double *ctable; TMAT_Formula returned; //----------------------------------------------------- *leng = 0; *error = 0; returned.code = NULL; returned.ctable = NULL; i_error = NULL; //----------------------------------------------------- source = (SG_Char *)SG_Malloc((SG_STR_LEN(sourc) + 1) * sizeof(SG_Char)); if( source == NULL ) { _Set_Error(LNG("no memory")); return( returned ); } SG_STR_CPY(source, sourc); for(scan=source; *scan!=SG_T('\0'); scan++) { if( islower(*scan) && !isalpha(*(scan + 1)) && (scan == source || !isalpha(*(scan - 1))) ) { for(scarg=args; *scarg!=SG_T('\0') && *scarg != *scan; scarg++) {} if( *scarg == SG_T('\0') ) { _Set_Error(LNG("undeclared parameter")); i_error = scan; *error = i_error - source; SG_Free(source); return (returned); } } } //----------------------------------------------------- size_estim = max_size(source); if( !(code =(SG_Char *) SG_Malloc(size_estim)) ) { _Set_Error(LNG("no memory")); *error = -1; SG_Free(source); return (returned); } //----------------------------------------------------- i_pctable = 0; if( !(i_ctable = (double *)SG_Malloc(MAX_CTABLE * sizeof(double))) ) { _Set_Error(LNG("no memory")); *error = -1; SG_Free(source); SG_Free(code); return (returned); } ctable = i_ctable; //----------------------------------------------------- _Set_Error(); result = i_trans(code, (SG_Char *)source, (SG_Char *)source + SG_STR_LEN(source)); if( !result || m_bError ) { *error = i_error ? i_error - source : -1; SG_Free(source); SG_Free(code); SG_Free(i_ctable); return (returned); } else { *result = SG_T('\0'); *error = -1; *leng = result - code; if( ((*leng) + 1) * sizeof(SG_Char) > size_estim ) { _Set_Error(LNG("I4: size estimate too small")); SG_Free(source); return( returned ); } else if( ((*leng) + 1) * sizeof(SG_Char) < size_estim ) { nfunc = (SG_Char *) SG_Malloc(((*leng) + 1) * sizeof(SG_Char)); if (nfunc) { memcpy(nfunc, code, ((*leng) + 1) * sizeof(SG_Char)); SG_Free(code); code = nfunc; } } if( i_pctable < MAX_CTABLE ) { ctable = (double *)SG_Malloc(i_pctable * sizeof(double)); if( ctable ) { memcpy(ctable, i_ctable, i_pctable * sizeof(double)); SG_Free(i_ctable); } else { ctable = i_ctable; } } else { ctable = i_ctable; } returned.code = code; returned.ctable = ctable; _Set_Error(); SG_Free(source); return (returned); } }