//--------------------------------------------------------- bool CSeparate_by_Direction::On_Execute(void) { int iSector, dir_Field; CSG_Shapes *pPoints; CSG_Parameter_Shapes_List *pOutput; //----------------------------------------------------- pOutput = Parameters("OUTPUT") ->asShapesList(); pPoints = Parameters("POINTS") ->asShapes(); m_Tolerance = Parameters("TOLERANCE") ->asDouble() * M_DEG_TO_RAD; m_nSectors = Parameters("DIRECTIONS") ->asInt(); m_dSector = M_PI_360 / m_nSectors; if( !pPoints || !pPoints->is_Valid() || pPoints->Get_Count() < 3 ) { return( false ); } //----------------------------------------------------- pOutput->Del_Items(); dir_Field = pPoints->Get_Field_Count(); for(iSector=0; iSector<m_nSectors; iSector++) { pOutput->Add_Item(SG_Create_Shapes(SHAPE_TYPE_Point, CSG_String::Format(SG_T("Direction %.2f"), iSector * m_dSector * M_RAD_TO_DEG), pPoints)); pOutput->asShapes(iSector)->Add_Field(_TL("Direction"), SG_DATATYPE_Double); } //----------------------------------------------------- int iPoint; double dir_A, dir_B, dir, dif; CSG_Shape *pt_A, *pt_B; pt_B = pPoints->Get_Shape(pPoints->Get_Count() - 2); pt_A = pPoints->Get_Shape(pPoints->Get_Count() - 1); dir_A = SG_Get_Angle_Of_Direction(pt_B->Get_Point(0), pt_A->Get_Point(0)); for(iPoint=0; iPoint<pPoints->Get_Count() && Set_Progress(iPoint, pPoints->Get_Count()); iPoint++) { pt_B = pt_A; pt_A = pPoints->Get_Shape(iPoint); dir_B = dir_A; dir_A = SG_Get_Angle_Of_Direction(pt_B->Get_Point(0), pt_A->Get_Point(0)); dif = fmod(dir_A - dir_B, M_PI_360); if( dif > M_PI_180 ) { dif -= M_PI_360; } else if( dif < -M_PI_180 ) { dif += M_PI_360; } if( fabs(dif) <= m_Tolerance ) { dir = dir_B + 0.5 * dif; iSector = (int)(fmod(M_PI_360 + 0.5 * m_dSector + dir, M_PI_360) / m_dSector); if( iSector >= 0 && iSector < m_nSectors ) { pOutput->asShapes(iSector)->Add_Shape(pt_B)->Set_Value(dir_Field, dir * M_RAD_TO_DEG); } } } //----------------------------------------------------- for(iSector=pOutput->Get_Count()-1; iSector>=0; iSector--) { if( pOutput->asShapes(iSector)->Get_Count() == 0 ) { delete(pOutput->asShapes(iSector)); pOutput->Del_Item(iSector); } } //----------------------------------------------------- return( pOutput->Get_Count() > 0 ); }
//--------------------------------------------------------- bool CTable_Trend_Base::On_Execute(void) { int i, j, xField, yField; CSG_String Name; CSG_Table_Record *pRecord; CSG_Table *pTable; pTable = Parameters("TABLE") ->asTable(); xField = Parameters("FIELD_X") ->asInt(); yField = Parameters("FIELD_Y") ->asInt(); //----------------------------------------------------- if( m_Trend.Set_Formula(Parameters("FORMULA")->asString()) ) { m_Trend.Clr_Data(); for(i=0; i<pTable->Get_Record_Count(); i++) { pRecord = pTable->Get_Record(i); m_Trend.Add_Data(pRecord->asDouble(xField), pRecord->asDouble(yField)); } //------------------------------------------------- if( m_Trend.Get_Trend() ) { Message_Fmt("\n%s\n%s: %f", m_Trend.Get_Formula().c_str(), SG_T("r\xb2"), 100.0 * m_Trend.Get_R2()); if( Parameters("TREND")->asTable() == NULL ) { pTable->Add_Field("TREND" , SG_DATATYPE_Double); for(i=0, j=pTable->Get_Field_Count()-1; i<m_Trend.Get_Data_Count(); i++) { pRecord = pTable->Get_Record(i); pRecord->Set_Value(j, m_Trend.Get_Value(m_Trend.Get_Data_X(i))); } } else { Name.Printf("%s [%s]", pTable->Get_Name(), _TL("Trend")); pTable = Parameters("TREND")->asTable(); pTable->Destroy(); pTable->Set_Name(Name); pTable->Add_Field("X" , SG_DATATYPE_Double); pTable->Add_Field("Y" , SG_DATATYPE_Double); pTable->Add_Field("Y_TREND", SG_DATATYPE_Double); for(i=0; i<m_Trend.Get_Data_Count(); i++) { pRecord = pTable->Add_Record(); pRecord->Set_Value(0, m_Trend.Get_Data_X(i)); pRecord->Set_Value(1, m_Trend.Get_Data_Y(i)); pRecord->Set_Value(2, m_Trend.Get_Value(m_Trend.Get_Data_X(i))); } } return( true ); } } return( false ); }
//--------------------------------------------------------- CParam_Scale::CParam_Scale(void) { Set_Name (_TL("Morphometric Features")); Set_Author (SG_T("O.Conrad (c) 2013")); Set_Description (_TW( "Uses a multi-scale approach by fitting quadratic " "parameters to any size window (via least squares) " "to derive slope, aspect and curvatures (optional output) " "for subsequent classification of morphometric features " "(peaks, ridges, passes, channels, pits and planes). " "This is the method as proposed and implemented by Jo Wood " "(1996) in LandSerf and GRASS GIS (r.param.scale). " "\n\n" "Optional output is described in the following. " "Generalised elevation is the smoothed input DEM. " "Slope is the magnitude of maximum gradient. It is given " "for steepest slope angle and measured in degrees. " "Aspect is the direction of maximum gradient. " "Profile curvature is the curvature intersecting with the " "plane defined by the Z axis and maximum gradient direction. " "Positive values describe convex profile curvature, negative " "values concave profile. Plan curvature is the horizontal " "curvature, intersecting with the XY plane. Longitudinal " "curvature is the profile curvature intersecting with the " "plane defined by the surface normal and maximum gradient " "direction. Cross-sectional curvature is the tangential " "curvature intersecting with the plane defined by the surface " "normal and a tangent to the contour - perpendicular to " "maximum gradient direction. Minimum curvature is measured " "in direction perpendicular to the direction of of maximum " "curvature. The maximum curvature is measured in any direction. " "\n\n" "References:" "\n\n" "Wood, J. (1996): The Geomorphological characterisation of Digital Elevation Models. " "Diss., Department of Geography, University of Leicester, U.K. " "<a target=\"_blank\" href=\"http://www.soi.city.ac.uk/~jwo/phd/\">online</a>." "\n\n" "Wood, J. (2009): Geomorphometry in LandSerf. " "In: Hengl, T. and Reuter, H.I. [Eds.]: Geomorphometry: Concepts, Software, Applications. " "Developments in Soil Science, Elsevier, Vol.33, 333-349." "\n\n" "<a target=\"_blank\" href=\"http://www.landserf.org/\">LandSerf Homepage</a>." )); //----------------------------------------------------- Parameters.Add_Grid( NULL , "DEM" , _TL("Elevation"), _TL(""), PARAMETER_INPUT ); Parameters.Add_Grid(NULL, "FEATURES" , _TL("Morphometric Features") , _TL(""), PARAMETER_OUTPUT, true, SG_DATATYPE_Byte); Parameters.Add_Grid(NULL, "ELEVATION", _TL("Generalized Surface") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "SLOPE" , _TL("Slope") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "ASPECT" , _TL("Aspect") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "PROFC" , _TL("Profile Curvature") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "PLANC" , _TL("Plan Curvature") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "LONGC" , _TL("Longitudinal Curvature") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "CROSC" , _TL("Cross-Sectional Curvature"), _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "MAXIC" , _TL("Maximum Curvature") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Grid(NULL, "MINIC" , _TL("Minimum Curvature") , _TL(""), PARAMETER_OUTPUT_OPTIONAL); Parameters.Add_Value( NULL , "SIZE" , _TL("Scale Radius (Cells)"), _TL("Size of processing window (= 1 + 2 * radius) given as number of cells"), PARAMETER_TYPE_Int, 5, 1, true ); Parameters.Add_Value( NULL , "TOL_SLOPE" , _TL("Slope Tolerance"), _TL("Slope tolerance that defines a 'flat' surface (degrees)"), PARAMETER_TYPE_Double, 1.0 ); Parameters.Add_Value( NULL , "TOL_CURVE" , _TL("Curvature Tolerance"), _TL("Curvature tolerance that defines 'planar' surface"), PARAMETER_TYPE_Double, 0.0001 ); Parameters.Add_Value( NULL , "EXPONENT" , _TL("Distance Weighting Exponent"), _TL("Exponent for distance weighting (0.0-4.0)"), PARAMETER_TYPE_Double, 0.0, 0.0, true, 4.0, true ); Parameters.Add_Value( NULL , "ZSCALE" , _TL("Vertical Scaling"), _TL("Vertical scaling factor"), PARAMETER_TYPE_Double, 1.0 ); Parameters.Add_Value( NULL , "CONSTRAIN" , _TL("Constrain"), _TL("Constrain model through central window cell"), PARAMETER_TYPE_Bool, false ); }
//--------------------------------------------------------- inline void CVIEW_Map_Control::_Set_StatusBar(CSG_Point ptWorld) { static bool bBuisy = false; if( bBuisy == false ) { bBuisy = true; CSG_Tool *pProjector = NULL; if( m_pMap->Get_Parameter("GCS_POSITION")->asBool() && m_pMap->Get_Projection().is_Okay() && (pProjector = SG_Get_Tool_Library_Manager().Get_Tool("pj_proj4", 2)) != NULL ) // Coordinate Transformation (Shapes) { if( pProjector->is_Executing() ) { pProjector = NULL; } else { SG_UI_Progress_Lock(true); SG_UI_Msg_Lock (true); CSG_Shapes prj(SHAPE_TYPE_Point), gcs(SHAPE_TYPE_Point); prj.Add_Shape()->Add_Point(ptWorld); prj.Get_Projection().Assign(m_pMap->Get_Projection()); pProjector->Settings_Push(NULL); if( pProjector->Set_Parameter("CRS_PROJ4", SG_T("+proj=longlat +ellps=WGS84 +datum=WGS84")) && pProjector->Set_Parameter("SOURCE" , &prj) && pProjector->Set_Parameter("TARGET" , &gcs) && pProjector->Execute() ) { CSG_Point ptWorld_gcs = gcs.Get_Shape(0)->Get_Point(0); STATUSBAR_Set_Text(wxString::Format("X %s", SG_Double_To_Degree(ptWorld_gcs.Get_X()).c_str()), STATUSBAR_VIEW_X); STATUSBAR_Set_Text(wxString::Format("Y %s", SG_Double_To_Degree(ptWorld_gcs.Get_Y()).c_str()), STATUSBAR_VIEW_Y); pProjector->Settings_Pop(); } else { pProjector->Settings_Pop(); pProjector = NULL; } SG_UI_Progress_Lock(false); SG_UI_Msg_Lock (false); } } if( !pProjector ) { STATUSBAR_Set_Text(wxString::Format("X %f", ptWorld.Get_X()), STATUSBAR_VIEW_X); STATUSBAR_Set_Text(wxString::Format("Y %f", ptWorld.Get_Y()), STATUSBAR_VIEW_Y); } if( m_Mode == MAP_MODE_DISTANCE ) { STATUSBAR_Set_Text(wxString::Format("D %f", m_Distance + m_Distance_Move), STATUSBAR_VIEW_Z); } else if( Get_Active_Layer() ) { STATUSBAR_Set_Text(wxString::Format("Z %s", Get_Active_Layer()->Get_Value(ptWorld, _Get_World(2.0)).c_str()), STATUSBAR_VIEW_Z); } else { STATUSBAR_Set_Text("Z", STATUSBAR_VIEW_Z); } bBuisy = false; } }
//--------------------------------------------------------- CGrid_Fill::CGrid_Fill(void) { //----------------------------------------------------- // 1. Info... Set_Name (_TL("Change Grid Values - Flood Fill")); Set_Author (SG_T("(c) 2005 by A.Ringeler, (c) 2006 by O.Conrad")); Set_Description (_TW( "Interactively use the flood fill method to replace a grid's cell values. " "If the target is not set, the changes will be stored to the original grid. ") ); //----------------------------------------------------- // 2. Parameters... Parameters.Add_Grid( NULL , "GRID_IN" , _TL("Grid"), _TL(""), PARAMETER_INPUT ); Parameters.Add_Grid( NULL , "GRID_OUT" , _TL("Changed Grid"), _TL(""), PARAMETER_OUTPUT_OPTIONAL ); Parameters.Add_Value( NULL , "FILL" , _TL("Fill Value"), _TL(""), PARAMETER_TYPE_Double, 1 ); Parameters.Add_Choice( NULL , "METHOD" , _TL("Value to be replaced"), _TL(""), CSG_String::Format(SG_T("%s|%s|%s|"), _TL("value at mouse position"), _TL("fixed value"), _TL("tolerance as absolute values") ), 0 ); Parameters.Add_Value( NULL , "ZFIXED" , _TL("Fixed value to be replaced"), _TL(""), PARAMETER_TYPE_Double, 0.0 ); Parameters.Add_Value( NULL , "DZMAX" , _TL("Upper Tolerance"), _TL(""), PARAMETER_TYPE_Double, 1.0 ); Parameters.Add_Value( NULL , "DZMIN" , _TL("Lower Tolerance"), _TL(""), PARAMETER_TYPE_Double, -1.0 ); Parameters.Add_Value( NULL , "NODATA" , _TL("Fill NoData"), _TL(""), PARAMETER_TYPE_Bool, false ); }
//--------------------------------------------------------- CGrid_Value_Reclassify::CGrid_Value_Reclassify(void) { CSG_Parameter *pNode; //----------------------------------------------------- Set_Name(_TL("Reclassify Grid Values")); Set_Author(_TL("Copyrights (c) 2005 by Volker Wichmann")); Set_Description (_TW( "The module can be used to reclassify the values of a grid. It provides three different options: (a) " "reclassification of single values, (b) reclassification of a range of values and (c) reclassification " "of value ranges specified in a lookup table. In addition to theses methods, two special cases " "(No-Data values and values not included in the reclassification setup) are supported. In mode (a) " "and (b) the 'No-Data option' is evaluated before the method settings, in mode (c) the option is " "evaluated only if the No-Data value ins't included in the lookup table. The 'other values' option " "is always evaluated after checking the method settings. ") ); //----------------------------------------------------- Parameters.Add_Grid( NULL , "INPUT" ,_TL("Grid"), _TL("Grid to reclassify"), PARAMETER_INPUT ); Parameters.Add_Grid( NULL , "RESULT" , _TL("Reclassified Grid"), _TL("Reclassifed grid."), PARAMETER_OUTPUT ); Parameters.Add_Choice( NULL , "METHOD" , _TL("Method"), _TL("Select the desired method: 1. a single value or a range defined by a single value is reclassified, 2. a range of values is reclassified, 3. the lookup table is used to reclassify the grid."), _TL("single|range|simple table|user supplied table|"), 0 ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "SINGLE", _TL("Method single"), _TL("Parameter settings for method single.") ); Parameters.Add_Value( pNode , "OLD" , _TL("old value"), _TL("Value to reclassify."), PARAMETER_TYPE_Double, 0 ); Parameters.Add_Value( pNode , "NEW" , _TL("new value"), _TL("New value."), PARAMETER_TYPE_Double, 1 ); Parameters.Add_Choice( pNode , "SOPERATOR" , _TL("operator"), _TL("Select the desired operator (<;.;=; >;.); it is possible to define a range above or below the old value."), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"), _TL("="), _TL("<"), _TL("<="), _TL(">="), _TL(">") ), 0 ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "RANGE" , _TL("Method range"), _TL("Parameter settings for method range.") ); Parameters.Add_Value( pNode , "MIN" , _TL("minimum value"), _TL("Minimum value of the range to be reclassified."), PARAMETER_TYPE_Double, 0 ); Parameters.Add_Value( pNode , "MAX" , _TL("maximum value"), _TL("Maximum value of the range to be reclassified."), PARAMETER_TYPE_Double, 10 ); Parameters.Add_Value( pNode , "RNEW" , _TL("new value"), _TL("new value"), PARAMETER_TYPE_Double, 5 ); Parameters.Add_Choice( pNode , "ROPERATOR" , _TL("operator"), _TL("Select operator: eg. min < value < max."), CSG_String::Format(SG_T("%s|%s|"), _TL("<="), _TL("<") ), 0 ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "TABLE" , _TL("Method simple table"), _TL("Parameter settings for method simple table.") ); Parameters.Add_FixedTable( pNode , "RETAB" , _TL("Lookup Table"), _TL("Lookup table used in method \"table\"") ); Parameters.Add_Choice( pNode , "TOPERATOR" , _TL("operator"), _TL("Select the desired operator (min < value < max; min . value < max; min .value . max; min < value . max)."), CSG_String::Format(SG_T("%s|%s|%s|%s|"), _TL("min <= value < max"), _TL("min <= value <= max"), _TL("min < value <= max"), _TL("min < value < max") ), 0 ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "TABLE_2" , _TL("Method user supplied table"), _TL("Parameter settings for method user supplied table.") ); pNode = Parameters.Add_Table( pNode , "RETAB_2" , _TL("Lookup Table"), _TL("Lookup table used in method \"user supplied table\""), PARAMETER_INPUT_OPTIONAL ); Parameters.Add_Table_Field( pNode , "F_MIN" , _TL("minimum value"), _TL("") ); Parameters.Add_Table_Field( pNode , "F_MAX" , _TL("maximum value"), _TL("") ); Parameters.Add_Table_Field( pNode , "F_CODE" , _TL("new value"), _TL("") ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL, "OPTIONS" , _TL("Special cases"), _TL("Parameter settings for No-Data and all other values.") ); Parameters.Add_Value( pNode , "NODATAOPT" , _TL("no data values"), _TL("Use this option to reclassify No-Data values independently of the method settings."), PARAMETER_TYPE_Bool, false ); Parameters.Add_Value( pNode , "NODATA" , _TL("no data values >> value"), _TL("new value"), PARAMETER_TYPE_Double, 0 ); Parameters.Add_Value( pNode , "OTHEROPT" , _TL("other values"), _TL("Use this option to reclassify all other values that are not specified in the options above."), PARAMETER_TYPE_Bool, false ); Parameters.Add_Value( pNode , "OTHERS" , _TL("other values >> value"), _TL("new value"), PARAMETER_TYPE_Double, 0 ); //----------------------------------------------------- CSG_Table *pLookup; CSG_Table_Record *pRecord; pLookup = Parameters("RETAB")->asTable(); pLookup->Add_Field(_TL("minimum") , SG_DATATYPE_Double); pLookup->Add_Field(_TL("maximum") , SG_DATATYPE_Double); pLookup->Add_Field(_TL("new") , SG_DATATYPE_Double); pRecord = pLookup->Add_Record(); pRecord->Set_Value(0, 0.0); pRecord->Set_Value(1, 10.0); pRecord->Set_Value(2, 1.0); pRecord = pLookup->Add_Record(); pRecord->Set_Value(0, 10.0); pRecord->Set_Value(1, 20.0); pRecord->Set_Value(2, 2.0); }
//--------------------------------------------------------- bool CDirect_Georeferencing_WorldFile::On_Execute(void) { //----------------------------------------------------- int nx = Parameters("NX")->asInt(); int ny = Parameters("NY")->asInt(); if( !m_Georeferencer.Set_Transformation(Parameters, nx, ny) ) { return( false ); } //----------------------------------------------------- CSG_String File = Parameters("FILE")->asString(); if( File.is_Empty() ) { return( false ); } //----------------------------------------------------- CSG_File Stream; if( !Stream.Open(File, SG_FILE_W, false) ) { return( false ); } //----------------------------------------------------- CSG_Matrix R(m_Georeferencer.Get_Transformation()); R *= 0.001 * Parameters("Z")->asDouble() / Parameters("CFL")->asDouble() * Parameters("PXSIZE")->asDouble(); TSG_Point p = m_Georeferencer.Image_to_World(0, ny); Stream.Printf(SG_T("%.10f\n%.10f\n%.10f\n%.10f\n%.10f\n%.10f\n"), R[0][0], // A: pixel size in the x-direction in map units/pixel R[1][0], // D: rotation about y-axis -R[0][1], // B: rotation about x-axis -R[1][1], // E: pixel size in the y-direction in map units, almost always negative p.x, // X: top left pixel center p.y // Y: top left pixel center ); //----------------------------------------------------- CSG_Shapes *pExtents = Parameters("EXTENT")->asShapes(); if( pExtents ) { pExtents->Create(SHAPE_TYPE_Polygon, SG_File_Get_Name(File, false)); pExtents->Add_Field(_TL("NAME"), SG_DATATYPE_String); CSG_Shape *pExtent = pExtents->Add_Shape(); p = m_Georeferencer.Image_to_World( 0, 0); pExtent->Add_Point(p.x, p.y); p = m_Georeferencer.Image_to_World( 0, ny); pExtent->Add_Point(p.x, p.y); p = m_Georeferencer.Image_to_World(nx, ny); pExtent->Add_Point(p.x, p.y); p = m_Georeferencer.Image_to_World(nx, 0); pExtent->Add_Point(p.x, p.y); pExtent->Set_Value(0, SG_File_Get_Name(File, false)); } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CShapes_Save::On_Execute(void) { if( !Get_Connection()->has_PostGIS() ) { Error_Set(_TL("not a valid PostGIS database!")); return( false ); } //----------------------------------------------------- CSG_Shapes *pShapes; CSG_String SQL, Name, Type, Field, SavePoint; pShapes = Parameters("SHAPES")->asShapes(); Name = Parameters("NAME" )->asString(); if( Name.Length() == 0 ) Name = pShapes->Get_Name(); Field = "geometry"; int SRID = Get_SRID(); //----------------------------------------------------- if( !CSG_Shapes_OGIS_Converter::from_ShapeType(Type, pShapes->Get_Type(), pShapes->Get_Vertex_Type()) ) { Error_Set(_TL("invalid or unsupported shape or vertex type")); return( false ); } //----------------------------------------------------- Get_Connection()->Begin(SavePoint = Get_Connection()->is_Transaction() ? "SHAPES_SAVE" : ""); //----------------------------------------------------- if( Get_Connection()->Table_Exists(Name) ) { Message_Add(_TL("table already exists") + CSG_String(": ") + Name); switch( Parameters("EXISTS")->asInt() ) { case 0: // abort export return( false ); case 1: // replace existing table Message_Add(_TL("trying to drop table") + CSG_String(": ") + Name); if( !Get_Connection()->Table_Drop(Name, false) ) { Message_Add(CSG_String(" ...") + _TL("failed") + "!"); return( false ); } break; case 2: // append records, if table structure allows break; } } //----------------------------------------------------- if( !Get_Connection()->Table_Exists(Name) ) { if( !Get_Connection()->Table_Create(Name, *pShapes, Get_Constraints(&Parameters, "SHAPES"), false) ) { Error_Set(_TL("could not create table")); Get_Connection()->Rollback(SavePoint); return( false ); } //------------------------------------------------- // SELECT AddGeometryColumn(<table_name>, <column_name>, <srid>, <type>, <dimension>) SQL.Printf(SG_T("SELECT AddGeometryColumn('%s', '%s', %d, '%s', %d)"), Name.c_str(), Field.c_str(), SRID, Type.c_str(), pShapes->Get_Vertex_Type() == SG_VERTEX_TYPE_XY ? 2 : pShapes->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZ ? 3 : 4 ); if( !Get_Connection()->Execute(SQL) ) { Error_Set(_TL("could not create geometry field")); Get_Connection()->Rollback(SavePoint); return( false ); } } //----------------------------------------------------- bool bBinary = Get_Connection()->has_Version(9); int iShape, iField, nAdded; CSG_String Insert = "INSERT INTO \"" + Name + "\" (" + Field; for(iField=0; iField<pShapes->Get_Field_Count(); iField++) { Insert += CSG_String(", ") + pShapes->Get_Field_Name(iField); } Insert += ") VALUES ("; //----------------------------------------------------- for(iShape=0, nAdded=0; iShape==nAdded && iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++) { CSG_Shape *pShape = pShapes->Get_Shape(iShape); if( pShape->is_Valid() ) { SQL = Insert; if( bBinary ) { CSG_Bytes WKB; CSG_Shapes_OGIS_Converter::to_WKBinary(pShape, WKB); SQL += "ST_GeomFromWKB(E'\\\\x" + WKB.toHexString() + CSG_String::Format("', %d)", SRID); } else { CSG_String WKT; CSG_Shapes_OGIS_Converter::to_WKText(pShape, WKT); SQL += "ST_GeomFromText('" + WKT + CSG_String::Format("', %d)", SRID); } for(iField=0; iField<pShapes->Get_Field_Count(); iField++) { CSG_String s = pShape->asString(iField); if( pShapes->Get_Field_Type(iField) == SG_DATATYPE_String ) { if( 1 ) { char *_s = NULL; if( s.to_ASCII(&_s) ) s = _s; SG_FREE_SAFE(_s); } s.Replace("'", "\""); s = "'" + s + "'"; } SQL += ", " + s; } SQL += ")"; if( Get_Connection()->Execute(SQL) ) { nAdded++; } else { Message_Add(CSG_String::Format("%s [%d/%d]", _TL("could not save shape"), 1 + iShape, pShapes->Get_Count())); } } } //----------------------------------------------------- if( nAdded < pShapes->Get_Count() ) { Message_Add(SQL); Get_Connection()->Rollback(SavePoint); return( false ); } Get_Connection()->Commit(SavePoint); Get_Connection()->GUI_Update(); Get_Connection()->Add_MetaData(*pShapes, Name); pShapes->Set_Modified(false); return( true ); }
//--------------------------------------------------------- bool CWKSP_Project::_Load(const wxString &FileName, bool bAdd, bool bUpdateMenu) { if( wxFileExists(FileName) && !bAdd && g_pData->Get_Count() > 0 ) { switch( DLG_Message_YesNoCancel(_TL("Close all data sets"), _TL("Load Project")) ) { case 0: if( !g_pData->Close(true) ) return( false ); break; case 2: return( false ); } } //------------------------------------------------- MSG_General_Add_Line(); MSG_General_Add(wxString::Format(wxT("%s: %s"), _TL("Load project"), FileName), true, true); //------------------------------------------------- bool bSuccess = false; CSG_MetaData Project, *pNode; if( _Compatibility_Load_Data(FileName) ) { bSuccess = true; } else if( !wxFileExists(FileName) ) { MSG_Error_Add(_TL("file does not exist." ), true, true, SG_UI_MSG_STYLE_FAILURE); } else if( !Project.Load(&FileName) ) { MSG_Error_Add(_TL("could not read project file." ), true, true, SG_UI_MSG_STYLE_FAILURE); } else if( Project.Get_Name().Cmp(SG_T("SAGA_PROJECT")) ) { MSG_Error_Add(_TL("invalid project file." ), true, true, SG_UI_MSG_STYLE_FAILURE); } else if( (pNode = Project.Get_Child(SG_T("DATA"))) == NULL || pNode->Get_Children_Count() <= 0 ) { MSG_Error_Add(_TL("no data entries in project file."), true, true, SG_UI_MSG_STYLE_FAILURE); } else if( !_Load_DBConnections(*pNode) ) { MSG_Error_Add(_TL("could not connect to database." ), true, true, SG_UI_MSG_STYLE_FAILURE); } else { int i; CSG_String Version(Project.Get_Property("VERSION")); bSuccess = true; //------------------------------------------------- g_pData->Get_Menu_Files()->Set_Update(false); for(i=0; i<pNode->Get_Children_Count(); i++) { _Load_Data(*pNode->Get_Child(i), SG_File_Get_Path(FileName).w_str(), true , Version); } for(i=0; i<pNode->Get_Children_Count(); i++) { _Load_Data(*pNode->Get_Child(i), SG_File_Get_Path(FileName).w_str(), false, Version); } g_pData->Get_Menu_Files()->Set_Update(true); //------------------------------------------------- g_pSAGA_Frame->Freeze(); if( (pNode = Project.Get_Child("MAPS")) != NULL && pNode->Get_Children_Count() > 0 ) { for(int j=0; j<pNode->Get_Children_Count(); j++) { _Load_Map(*pNode->Get_Child(j), SG_File_Get_Path(FileName).w_str()); } } switch( g_pData->Get_Parameter("PROJECT_MAP_ARRANGE")->asInt() ) { case 1: g_pSAGA_Frame->Tile(wxHORIZONTAL); break; case 2: g_pSAGA_Frame->Tile(wxVERTICAL ); break; } g_pSAGA_Frame->Thaw(); } //----------------------------------------------------- if( bSuccess ) { if( bUpdateMenu ) { g_pData->Get_Menu_Files()->Recent_Add(DATAOBJECT_TYPE_Undefined, FileName); } MSG_General_Add(_TL("Project has been successfully loaded."), true, true, SG_UI_MSG_STYLE_SUCCESS); m_File_Name = FileName; _Set_Project_Name(); return( true ); } if( bUpdateMenu ) { g_pData->Get_Menu_Files()->Recent_Del(DATAOBJECT_TYPE_Undefined, FileName); } MSG_General_Add(_TL("Could not load project."), true, true, SG_UI_MSG_STYLE_FAILURE); return( false ); }
//--------------------------------------------------------- bool CKriging_Base::On_Execute(void) { bool bResult = false; //----------------------------------------------------- m_Block = Parameters("BLOCK" )->asBool() ? Parameters("DBLOCK")->asDouble() / 2.0 : 0.0; m_bStdDev = Parameters("TQUALITY")->asInt() == 0; m_bLog = Parameters("LOG" )->asBool(); m_pPoints = Parameters("POINTS" )->asShapes(); m_zField = Parameters("ZFIELD" )->asInt(); if( m_pPoints->Get_Count() <= 1 ) { SG_UI_Msg_Add(_TL("not enough points for interpolation"), true); return( false ); } //----------------------------------------------------- CSG_Table Variogram; if( SG_UI_Get_Window_Main() ) { static CVariogram_Dialog dlg; if( dlg.Execute(m_pPoints, m_zField, m_bLog, &Variogram, &m_Model) ) { bResult = true; } } else { int nSkip = Parameters("VAR_NSKIP" )->asInt(); int nClasses = Parameters("VAR_NCLASSES")->asInt(); double maxDistance = Parameters("VAR_MAXDIST" )->asDouble(); m_Model.Set_Formula(Parameters("VAR_MODEL")->asString()); if( CSG_Variogram::Calculate(m_pPoints, m_zField, m_bLog, &Variogram, nClasses, maxDistance, nSkip) ) { m_Model.Clr_Data(); for(int i=0; i<Variogram.Get_Count(); i++) { CSG_Table_Record *pRecord = Variogram.Get_Record(i); m_Model.Add_Data(pRecord->asDouble(CSG_Variogram::FIELD_DISTANCE), pRecord->asDouble(CSG_Variogram::FIELD_VAR_EXP)); } bResult = m_Model.Get_Trend() || m_Model.Get_Parameter_Count() == 0; } } //----------------------------------------------------- if( bResult && (bResult = _Initialise_Grids() && On_Initialize()) ) { Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("variogram model"), m_Model.Get_Formula(SG_TREND_STRING_Formula_Parameters).c_str()), false); for(int y=0; y<m_pGrid->Get_NY() && Set_Progress(y, m_pGrid->Get_NY()); y++) { #pragma omp parallel for for(int x=0; x<m_pGrid->Get_NX(); x++) { double z, v; if( Get_Value(m_pGrid->Get_System().Get_Grid_to_World(x, y), z, v) ) { Set_Value(x, y, z, v); } else { Set_NoData(x, y); } } } } //----------------------------------------------------- m_Model.Clr_Data(); On_Finalize(); return( bResult ); }
//--------------------------------------------------------- CKriging_Base::CKriging_Base(void) { CSG_Parameter *pNode; CSG_Parameters *pParameters; //----------------------------------------------------- pNode = Parameters.Add_Shapes( NULL , "POINTS" , _TL("Points"), _TL(""), PARAMETER_INPUT, SHAPE_TYPE_Point ); Parameters.Add_Table_Field( pNode , "ZFIELD" , _TL("Attribute"), _TL("") ); //----------------------------------------------------- Parameters.Add_Choice( NULL , "TARGET" , _TL("Target Grid"), _TL(""), CSG_String::Format(SG_T("%s|%s|"), _TL("user defined"), _TL("grid") ), 0 ); Parameters.Add_Choice( NULL , "TQUALITY" , _TL("Type of Quality Measure"), _TL(""), CSG_String::Format(SG_T("%s|%s|"), _TL("standard deviation"), _TL("variance") ), 0 ); //----------------------------------------------------- Parameters.Add_Value( NULL , "LOG" , _TL("Logarithmic Transformation"), _TL(""), PARAMETER_TYPE_Bool ); pNode = Parameters.Add_Value( NULL , "BLOCK" , _TL("Block Kriging"), _TL(""), PARAMETER_TYPE_Bool , false ); Parameters.Add_Value( pNode , "DBLOCK" , _TL("Block Size"), _TL(""), PARAMETER_TYPE_Double , 100.0, 0.0, true ); /////////////////////////////////////////////////////// //----------------------------------------------------- if( !SG_UI_Get_Window_Main() ) { Parameters.Add_Value( NULL , "VAR_MAXDIST" , _TL("Maximum Distance"), _TL(""), PARAMETER_TYPE_Double , -1.0 ); Parameters.Add_Value( NULL , "VAR_NCLASSES" , _TL("Lag Distance Classes"), _TL("initial number of lag distance classes"), PARAMETER_TYPE_Int , 100, 1, true ); Parameters.Add_Value( NULL , "VAR_NSKIP" , _TL("Skip"), _TL(""), PARAMETER_TYPE_Int, 1, 1, true ); Parameters.Add_String( NULL , "VAR_MODEL" , _TL("Model"), _TL(""), SG_T("a + b * x") ); } /////////////////////////////////////////////////////// //----------------------------------------------------- pParameters = Add_Parameters("USER", _TL("User Defined Grid") , _TL("")); pParameters->Add_Value( NULL , "BVARIANCE" , _TL("Create Quality Grid"), _TL(""), PARAMETER_TYPE_Bool, true ); m_Grid_Target.Add_Parameters_User(pParameters); //----------------------------------------------------- pParameters = Add_Parameters("GRID", _TL("Choose Grid") , _TL("")); m_Grid_Target.Add_Parameters_Grid(pParameters); //----------------------------------------------------- m_Grid_Target.Add_Grid_Parameter(SG_T("VARIANCE"), _TL("Quality Measure"), true); }
//--------------------------------------------------------- CShapes_Buffer::CShapes_Buffer(void) { CSG_Parameter *pNode; //----------------------------------------------------- Set_Name (_TL("Shapes Buffer")); Set_Author (SG_T("O.Conrad (c) 2008")); Set_Description (_TW( "A vector based buffer construction partly based on the method supposed by Dong et al. 2003. " "\n\n" "References:\n" "Dong, P, Yang, C., Rui, X., Zhang, L., Cheng, Q. (2003): " "'An effective buffer generation method in GIS'. " "Geoscience and Remote Sensing Symposium, 2003. " "IGARSS '03. Proceedings. 2003 IEEE International, Vol.6, p.3706-3708.\n" "<a href=\"http://ieeexplore.ieee.org/iel5/9010/28606/01295244.pdf\">online version</a>\n" )); //----------------------------------------------------- pNode = Parameters.Add_Shapes( NULL , "SHAPES" , _TL("Shapes"), _TL(""), PARAMETER_INPUT ); Parameters.Add_Shapes( NULL , "BUFFER" , _TL("Buffer"), _TL(""), PARAMETER_OUTPUT, SHAPE_TYPE_Polygon ); pNode = Parameters.Add_Table_Field_or_Const( pNode , "DIST_FIELD" , _TL("Buffer Distance"), _TL(""), 100.0, 0.0, true ); Parameters.Add_Value( pNode , "DIST_SCALE" , _TL("Scaling Factor for Attribute Value"), _TL(""), PARAMETER_TYPE_Double, 1.0, 0.0, true ); Parameters.Add_Value( NULL , "DISSOLVE" , _TL("Dissolve Buffers"), _TL(""), PARAMETER_TYPE_Bool, true ); Parameters.Add_Value( NULL , "NZONES" , _TL("Number of Buffer Zones"), _TL(""), PARAMETER_TYPE_Int, 1, 1, true ); Parameters.Add_Value( NULL , "POLY_INNER" , _TL("Inner Buffer"), _TL(""), PARAMETER_TYPE_Bool, false ); Parameters.Add_Value( NULL , "DARC" , _TL("Arc Vertex Distance [Degree]"), _TL(""), PARAMETER_TYPE_Double, 5.0, 0.01, true, 45.0, true ); }
//--------------------------------------------------------- bool CShapes_Buffer::On_Execute(void) { int Field, nZones; CSG_Shapes *pShapes, *pBuffers; //----------------------------------------------------- pShapes = Parameters("SHAPES" )->asShapes(); pBuffers = Parameters("BUFFER" )->asShapes(); nZones = Parameters("NZONES" )->asInt(); Field = Parameters("DIST_FIELD")->asInt(); m_dArc = Parameters("DARC" )->asDouble() * M_DEG_TO_RAD; m_bPolyInner = Parameters("POLY_INNER")->asBool() && pShapes->Get_Type() == SHAPE_TYPE_Polygon; //----------------------------------------------------- if( !pShapes->is_Valid() ) { Message_Add(_TL("Invalid Shapes")); return( false ); } if( Field < 0 && Parameters("DIST_FIELD")->asDouble() <= 0.0 ) { Message_Add(_TL("Invalid Buffer Distance")); return( false ); } //----------------------------------------------------- if( nZones == 1 ) { Get_Buffers(pShapes, Field, pBuffers, 1.0, Parameters("DISSOLVE")->asBool()); } //----------------------------------------------------- else if( nZones > 1 ) { CSG_Shape *pBuffer; CSG_Shapes Buffers; pBuffers->Create(SHAPE_TYPE_Polygon); pBuffers->Add_Field(_TL("ID") , SG_DATATYPE_Int); pBuffers->Add_Field(_TL("ZONE") , SG_DATATYPE_Double); double dZone = 1.0 / nZones; for(int iZone=0; iZone<nZones; iZone++) { Get_Buffers(pShapes, Field, &Buffers, (nZones - iZone) * dZone, true); if( iZone > 0 ) { SG_Polygon_Difference(pBuffer, Buffers.Get_Shape(0)); } pBuffer = pBuffers->Add_Shape(Buffers.Get_Shape(0)); pBuffer ->Set_Value(0, (nZones - iZone) + 1); pBuffer ->Set_Value(1, (nZones - iZone) * dZone * 100.0); } } //----------------------------------------------------- pBuffers->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pShapes->Get_Name(), _TL("Buffer"))); return( pBuffers->is_Valid() ); }
CSG_MetaData * CSG_MetaData::Ins_Child(const CSG_String &Name, int Content, int Position) { return( Ins_Child(Name, CSG_String::Format(SG_T("%d"), Content), Position) ); }
//--------------------------------------------------------- bool CGrid_IMCORR::On_Execute(void) { CSG_Grid *pGrid1, *pGrid2, *pDTM1, *pDTM2; CSG_Shapes *pCorrPts, *pCorrLines; CSG_Shape *pCorrPt, *pCorrLine; int Search_Chipsize, Ref_Chipsize, Grid_Spacing; double SpacingMetrics; pGrid1 = Parameters("GRID_1")->asGrid(); pGrid2 = Parameters("GRID_2")->asGrid(); pDTM1 = Parameters("DTM_1")->asGrid(); pDTM2 = Parameters("DTM_2")->asGrid(); pCorrPts = Parameters("CORRPOINTS")->asShapes(); pCorrLines = Parameters("CORRLINES")->asShapes(); Search_Chipsize = Parameters("SEARCH_CHIPSIZE")->asInt(); Ref_Chipsize = Parameters("REF_CHIPSIZE")->asInt(); SpacingMetrics = Parameters("GRID_SPACING")->asDouble(); Search_Chipsize = (int)(pow(2.0,4+Search_Chipsize)); Ref_Chipsize = (int)(pow(2.0,4+Ref_Chipsize)); if (Search_Chipsize < Ref_Chipsize) Search_Chipsize = Ref_Chipsize; CSG_String Message = CSG_String::Format(_TL("Search chip size set to %d"), Search_Chipsize); SG_UI_Msg_Add(Message,true); Message = CSG_String::Format(_TL("Reference chip size set to %d"), Ref_Chipsize); SG_UI_Msg_Add(Message,true); if (pDTM1 == NULL || pDTM2 == NULL) { CSG_String name = CSG_String::Format(_TL("%s_CORRPOINTS"), pGrid1->Get_Name()); pCorrPts->Create(SHAPE_TYPE_Point, name.c_str(), pCorrPts); pCorrPts->Add_Field(SG_T("ID"), SG_DATATYPE_Int); pCorrPts->Add_Field(SG_T("GX"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("GY"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("REALX"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("REALY"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("DISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("STRENGTH"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("FLAG"), SG_DATATYPE_Int); pCorrPts->Add_Field(SG_T("XDISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YDISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("XDISP_UNIT"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YDISP_UNIT"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("XTARG"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YTARG"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("XERR"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YERR"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("ASPECT"), SG_DATATYPE_Double); CSG_String name2 = CSG_String::Format(_TL("%s_DISP_VEC"), pGrid1->Get_Name()); pCorrLines->Create(SHAPE_TYPE_Line, name2.c_str(), pCorrLines); pCorrLines->Add_Field(SG_T("ID"), SG_DATATYPE_Int); pCorrLines->Add_Field(SG_T("GX"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("GY"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("REALX"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("REALY"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("DISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("STRENGTH"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("FLAG"), SG_DATATYPE_Int); pCorrLines->Add_Field(SG_T("XDISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YDISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("XDISP_UNIT"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YDISP_UNIT"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("XTARG"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YTARG"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("XERR"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YERR"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("ASPECT"), SG_DATATYPE_Double); } else // If DTM is given the Output gets 3D { CSG_String name = CSG_String::Format(_TL("%s_CORRPOINTS"), pGrid1->Get_Name()); pCorrPts->Create(SHAPE_TYPE_Point, name.c_str(), pCorrPts, SG_VERTEX_TYPE_XYZ); pCorrPts->Add_Field(SG_T("ID"), SG_DATATYPE_Int); pCorrPts->Add_Field(SG_T("GX"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("GY"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("REALX"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("REALY"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("REALZ"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("DISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("DISP_REAL"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("STRENGTH"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("FLAG"), SG_DATATYPE_Int); pCorrPts->Add_Field(SG_T("XDISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YDISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("ZDISP"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("XDISP_UNIT"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YDISP_UNIT"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("XTARG"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YTARG"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("ZTARG"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("XERR"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("YERR"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("ASPECT"), SG_DATATYPE_Double); pCorrPts->Add_Field(SG_T("SLOPE"), SG_DATATYPE_Double); CSG_String name2 = CSG_String::Format(_TL("%s_DISP_VEC"), pGrid1->Get_Name()); pCorrLines->Create(SHAPE_TYPE_Line, name2.c_str(), pCorrLines, SG_VERTEX_TYPE_XYZ); pCorrLines->Add_Field(SG_T("ID"), SG_DATATYPE_Int); pCorrLines->Add_Field(SG_T("GX"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("GY"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("REALX"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("REALY"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("REALZ"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("DISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("DISP_REAL"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("STRENGTH"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("FLAG"), SG_DATATYPE_Int); pCorrLines->Add_Field(SG_T("XDISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YDISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("ZDISP"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("XDISP_UNIT"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YDISP_UNIT"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("XTARG"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YTARG"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("ZTARG"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("XERR"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("YERR"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("ASPECT"), SG_DATATYPE_Double); pCorrLines->Add_Field(SG_T("SLOPE"), SG_DATATYPE_Double); } // create containers std::vector<std::vector<double> > SearchChip; SearchChip.resize(Search_Chipsize); for(int i = 0; i < Search_Chipsize; i++) SearchChip[i].resize(Search_Chipsize); std::vector<std::vector<double> > RefChip; RefChip.resize(Ref_Chipsize); for(int i = 0; i < Ref_Chipsize; i++) RefChip[i].resize(Ref_Chipsize); // defaults for values; double mincorr = 2.0; int fitmeth = 1, okparam = 1; double maxdis = -1.0; std::vector<double>ioffrq,nomoff; nomoff.push_back(0.0); nomoff.push_back((Search_Chipsize-Ref_Chipsize)*0.5); nomoff.push_back((Search_Chipsize-Ref_Chipsize)*0.5); ioffrq.push_back(0.0); ioffrq.push_back(Search_Chipsize/2); ioffrq.push_back(Search_Chipsize/2); double disp=0.0; double strength=0.0; std::vector<double>best_fit, est_err; Grid_Spacing = (int)(SpacingMetrics / (pGrid1->Get_Cellsize())); // enshures that chips are always in grid int ID = 0; for(int gx1 = (Search_Chipsize/2-1); gx1 < pGrid1->Get_NX()-(Search_Chipsize/2) && Set_Progress(gx1, pGrid1->Get_NX()-(Search_Chipsize/2)); gx1 += Grid_Spacing) { for(int gy1 = (Search_Chipsize/2-1); gy1 < pGrid1->Get_NY()-(Search_Chipsize/2); gy1 += Grid_Spacing) { // get ref_chip Get_This_Chip(RefChip, pGrid1, gx1, gy1, Ref_Chipsize); // get search chip Get_This_Chip(SearchChip, pGrid2, gx1, gy1, Search_Chipsize); gcorr(SearchChip, RefChip, mincorr, fitmeth, maxdis, ioffrq, nomoff, okparam, strength, best_fit, est_err, disp); if (okparam ==1) { disp = sqrt(best_fit[1]*best_fit[1] + best_fit[2]*best_fit[2]) * Get_Cellsize(); double DirNormX = (best_fit[2] * Get_Cellsize()) / disp; double DirNormY = (best_fit[1] * Get_Cellsize()) / disp; double Aspect; if((DirNormY > 0.0 && DirNormX > 0)) Aspect = (atan(fabs(DirNormX)/fabs(DirNormY)))*M_RAD_TO_DEG; else if ((DirNormY <= 0.0 && DirNormX > 0)) Aspect = 90+((atan(fabs(DirNormY)/fabs(DirNormX)))*M_RAD_TO_DEG); else if ((DirNormY <= 0.0 && DirNormX <= 0)) Aspect = 180+((atan(fabs(DirNormX)/fabs(DirNormY)))*M_RAD_TO_DEG); else Aspect = 270+((atan(fabs(DirNormY)/fabs(DirNormX)))*M_RAD_TO_DEG); double xReal = pGrid1->Get_System().Get_xGrid_to_World(gx1); double yReal = pGrid1->Get_System().Get_yGrid_to_World(gy1); double xReal2 = xReal + best_fit[2] * Get_Cellsize(); double yReal2 = yReal + best_fit[1] * Get_Cellsize(); if (pDTM1 == NULL || pDTM2 == NULL) { pCorrPt = pCorrPts->Add_Shape(); pCorrPt->Add_Point(xReal, yReal); pCorrPt->Set_Value(0, ID); pCorrPt->Set_Value(1, gx1); pCorrPt->Set_Value(2, gy1); pCorrPt->Set_Value(3, xReal); pCorrPt->Set_Value(4, yReal); pCorrPt->Set_Value(5, disp); pCorrPt->Set_Value(6, strength); pCorrPt->Set_Value(7, okparam); pCorrPt->Set_Value(8, best_fit[2] * Get_Cellsize()); pCorrPt->Set_Value(9, best_fit[1] * Get_Cellsize()); pCorrPt->Set_Value(10, DirNormX); pCorrPt->Set_Value(11, DirNormY); pCorrPt->Set_Value(12, xReal2); pCorrPt->Set_Value(13, yReal2); pCorrPt->Set_Value(14, est_err[2]); pCorrPt->Set_Value(15, est_err[1]); pCorrPt->Set_Value(16, Aspect); pCorrLine = pCorrLines->Add_Shape(); pCorrLine->Add_Point(xReal, yReal); pCorrLine->Add_Point(xReal2, yReal2); pCorrLine->Set_Value(0, ID); pCorrLine->Set_Value(1, gx1); pCorrLine->Set_Value(2, gy1); pCorrLine->Set_Value(3, xReal); pCorrLine->Set_Value(4, yReal); pCorrLine->Set_Value(5, disp); pCorrLine->Set_Value(6, strength); pCorrLine->Set_Value(7, okparam); pCorrLine->Set_Value(8, best_fit[2] * Get_Cellsize()); pCorrLine->Set_Value(9, best_fit[1] * Get_Cellsize()); pCorrLine->Set_Value(10, DirNormX); pCorrLine->Set_Value(11, DirNormY); pCorrLine->Set_Value(12, xReal2); pCorrLine->Set_Value(13, yReal2); pCorrLine->Set_Value(14, est_err[2]); pCorrLine->Set_Value(15, est_err[1]); pCorrLine->Set_Value(16, Aspect); } else { double zReal2 = pDTM2->Get_Value(xReal2, yReal2); double zReal = pDTM1->asDouble(gx1, gy1); double Slope = (atan((zReal2-zReal)/fabs(disp)))*M_RAD_TO_DEG; double dispReal = sqrt(pow(zReal2-zReal,2) + disp*disp); pCorrPt = pCorrPts->Add_Shape(); pCorrPt->Add_Point(xReal,yReal); pCorrPt->Set_Z(zReal,ID,0); pCorrPt->Set_Value(0, ID); pCorrPt->Set_Value(1, gx1); pCorrPt->Set_Value(2, gy1); pCorrPt->Set_Value(3, xReal); pCorrPt->Set_Value(4, yReal); pCorrPt->Set_Value(5, zReal); pCorrPt->Set_Value(6, disp); pCorrPt->Set_Value(7, dispReal); pCorrPt->Set_Value(8, strength); pCorrPt->Set_Value(9, okparam); pCorrPt->Set_Value(10, best_fit[2] * Get_Cellsize()); pCorrPt->Set_Value(11, best_fit[1] * Get_Cellsize()); pCorrPt->Set_Value(12, zReal2-zReal); pCorrPt->Set_Value(13, DirNormX); pCorrPt->Set_Value(14, DirNormY); pCorrPt->Set_Value(15, xReal2); pCorrPt->Set_Value(16, yReal2); pCorrPt->Set_Value(17, zReal2); pCorrPt->Set_Value(18, est_err[2]); pCorrPt->Set_Value(19, est_err[1]); pCorrPt->Set_Value(20, Aspect); pCorrPt->Set_Value(21, Slope); pCorrLine = pCorrLines->Add_Shape(); pCorrLine->Add_Point(xReal, yReal); pCorrLine->Set_Z(zReal,0,0); pCorrLine->Add_Point(xReal2, yReal2); pCorrLine->Set_Z(zReal2,1,0); pCorrLine->Set_Value(0, ID); pCorrLine->Set_Value(1, gx1); pCorrLine->Set_Value(2, gy1); pCorrLine->Set_Value(3, xReal); pCorrLine->Set_Value(4, yReal); pCorrLine->Set_Value(5, zReal); pCorrLine->Set_Value(6, disp); pCorrLine->Set_Value(7, dispReal); pCorrLine->Set_Value(8, strength); pCorrLine->Set_Value(9, okparam); pCorrLine->Set_Value(10, best_fit[2] * Get_Cellsize()); pCorrLine->Set_Value(11, best_fit[1] * Get_Cellsize()); pCorrLine->Set_Value(12, zReal2-zReal); pCorrLine->Set_Value(13, DirNormX); pCorrLine->Set_Value(14, DirNormY); pCorrLine->Set_Value(15, xReal2); pCorrLine->Set_Value(16, yReal2); pCorrLine->Set_Value(17, zReal2); pCorrLine->Set_Value(18, est_err[2]); pCorrLine->Set_Value(19, est_err[1]); pCorrLine->Set_Value(20, Aspect); pCorrLine->Set_Value(21, Slope); } ID++; } } } return( true ); }
CSG_MetaData * CSG_MetaData::Add_Child(const CSG_String &Name, int Content) { return( Add_Child(Name, CSG_String::Format(SG_T("%d"), Content)) ); }
//--------------------------------------------------------- CGrid_IMCORR::CGrid_IMCORR(void) { Set_Name (_TL("IMCORR - Feature Tracking")); Set_Author (SG_T("Magnus Bremer (c) 2012")); Set_Description (_TW( "The module performs an image correlation " "based on two raster data sets.\n" "Additionally, two DTMs can be given and used to optain 3D displacement vectors.\n\n" "This is a SAGA implementation of the standalone " "IMCORR software provided by the " "National Snow and Ice Data Center in Boulder, Colorado / US.\n\n" "The standalone software and documentation is available from:\n" "<a href=\"http://nsidc.org/data/velmap/imcorr.html\">http://nsidc.org/data/velmap/imcorr.html</a>\n\n" "References:\n" "Scambos, T. A., Dutkiewicz, M. J., Wilson, J. C., and R. A. Bindschadler (1992): " "Application of image cross-correlation to the measurement of glacier velocity " "using satellite image data. Remote Sensing Environ., 42(3), 177-186.\n\n" "Fahnestock, M. A., Scambos, T.A., and R. A. Bindschadler (1992): " "Semi-automated ice velocity determination from satellite imagery. Eos, 73, 493.\n\n" )); Parameters.Add_Grid( NULL , "GRID_1", _TL("Grid 1"), _TL("The first grid to correlate"), PARAMETER_INPUT ); Parameters.Add_Grid( NULL , "GRID_2" , _TL("Grid 2"), _TL("The second grid to correlate"), PARAMETER_INPUT ); Parameters.Add_Grid( NULL , "DTM_1", _TL("DTM 1"), _TL("The first DTM used to assign height information to grid 1"), PARAMETER_INPUT_OPTIONAL ); Parameters.Add_Grid( NULL , "DTM_2" , _TL("DTM 2"), _TL("The second DTM used to assign height information to grid 2"), PARAMETER_INPUT_OPTIONAL ); Parameters.Add_Shapes( NULL, "CORRPOINTS" , _TL("Correlated Points"), _TL("Correlated points with displacement and correlation information"), PARAMETER_OUTPUT, SHAPE_TYPE_Point ); Parameters.Add_Shapes( NULL, "CORRLINES" , _TL("Displacement Vector"), _TL("Displacement vectors between correlated points"), PARAMETER_OUTPUT, SHAPE_TYPE_Line ); Parameters.Add_Choice( NULL , "SEARCH_CHIPSIZE" , _TL("Search Chip Size (Cells)"), _TL("Chip size of search chip, used to find correlating reference chip"), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"), _TL("16x16"), _TL("32x32"), _TL("64x64"), _TL("128x128"), _TL("256x256") ), 2 ); Parameters.Add_Choice( NULL , "REF_CHIPSIZE" , _TL("Reference Chip Size (Cells)"), _TL("Chip size of reference chip to be found in search chip"), CSG_String::Format(SG_T("%s|%s|%s|%s|"), _TL("16x16"), _TL("32x32"), _TL("64x64"), _TL("128x128") ), 1 ); Parameters.Add_Value( NULL , "GRID_SPACING" , _TL("Grid Spacing (Map Units)"), _TL("Grid spacing used for the construction of correlated points [map units]"), PARAMETER_TYPE_Double, 10.0, 0.1, true, 256.0, true ); }
bool CSG_MetaData::Add_Property(const CSG_String &Name, int Value) { return( Add_Property(Name, CSG_String::Format(SG_T("%d"), Value)) ); }
//--------------------------------------------------------- CDirect_Georeferencing::CDirect_Georeferencing(void) { CSG_Parameter *pNode; //----------------------------------------------------- Set_Name (_TL("Direct Georeferencing of Airborne Photographs")); Set_Author (SG_T("O.Conrad (c) 2012")); Set_Description (_TW( "Direct georeferencing of aerial photographs uses extrinsic " "(position, attitude) and intrinsic (focal length, physical " "pixel size) camera parameters. Orthorectification routine supports " "additional data from a Digital Elevation Model (DEM).\n" "\nReferences:\n" "Baumker, M. / Heimes, F.J. (2001): " "New Calibration and Computing Method for Direct Georeferencing of Image and Scanner Data Using the Position and Angular Data of an Hybrid Inertial Navigation System. " "OEEPE Workshop, Integrated Sensor Orientation, Hannover 2001. " "<a target=\"_blank\" href=\"http://www.hochschule-bochum.de/fileadmin/media/fb_v/veroeffentlichungen/baeumker/baheimesoeepe.pdf\">online</a>.\n" )); //----------------------------------------------------- Parameters.Add_Grid_List( NULL , "INPUT" , _TL("Unreferenced Grids"), _TL(""), PARAMETER_INPUT ); Parameters.Add_Grid_List( NULL , "OUTPUT" , _TL("Referenced Grids"), _TL(""), PARAMETER_OUTPUT, false ); Parameters.Add_Shapes( NULL , "EXTENT" , _TL("Extent"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, SHAPE_TYPE_Polygon ); //----------------------------------------------------- pNode = Parameters.Add_Grid( NULL , "DEM" , _TL("Elevation"), _TL(""), PARAMETER_INPUT_OPTIONAL, false ); Parameters.Add_Value( pNode , "ZREF" , _TL("Default Reference Height"), _TL(""), PARAMETER_TYPE_Double , 0.0 ); //----------------------------------------------------- m_Georeferencer.Add_Parameters(Parameters); //----------------------------------------------------- Parameters.Add_Choice( NULL , "RESAMPLING" , _TL("Resampling"), _TL(""), CSG_String::Format("%s|%s|%s|%s|", _TL("Nearest Neighbour"), _TL("Bilinear Interpolation"), _TL("Bicubic Spline Interpolation"), _TL("B-Spline Interpolation") ), 3 ); Parameters.Add_Choice( NULL , "DATA_TYPE" , _TL("Data Storage Type"), _TL(""), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|%s|%s|%s|"), _TL("1 byte unsigned integer"), _TL("1 byte signed integer"), _TL("2 byte unsigned integer"), _TL("2 byte signed integer"), _TL("4 byte unsigned integer"), _TL("4 byte signed integer"), _TL("4 byte floating point"), _TL("8 byte floating point"), _TL("same as original") ), 8 ); Parameters.Add_Choice( NULL , "ROW_ORDER" , _TL("Row Order"), _TL(""), CSG_String::Format(SG_T("%s|%s|"), _TL("top down"), _TL("bottom up") ), 0 ); //----------------------------------------------------- m_Grid_Target.Create(Add_Parameters("TARGET", _TL("Target Grid System"), _TL("")), false); }
bool CSG_MetaData::Set_Property(const CSG_String &Name, int Value, bool bAddIfNotExists) { return( Set_Property(Name, CSG_String::Format(SG_T("%d"), Value, bAddIfNotExists)) ); }
//--------------------------------------------------------- bool CSG_Direct_Georeferencer::Add_Parameters(CSG_Parameters &Parameters) { CSG_Parameter *pNode; //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "NODE_POS" , _TL("Position"), _TL("") ); Parameters.Add_Value( pNode , "X" , _TL("X"), _TL(""), PARAMETER_TYPE_Double , 0.0 ); Parameters.Add_Value( pNode , "Y" , _TL("Y"), _TL(""), PARAMETER_TYPE_Double , 0.0 ); Parameters.Add_Value( pNode , "Z" , _TL("Flying Height"), _TL(""), PARAMETER_TYPE_Double , 1000.0 ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "NODE_DIR" , _TL("Orientation"), _TL("") ); Parameters.Add_Choice( pNode , "ORIENTATION" , _TL("Orientation"), _TL(""), CSG_String::Format(SG_T("%s|%s|"), _TL("BLUH"), _TL("PATB") ), 0 ); Parameters.Add_Value( pNode , "OMEGA" , _TL("Omega [degree]"), _TL("rotation around the X axis (roll)"), PARAMETER_TYPE_Double , 0.0 ); Parameters.Add_Value( pNode , "PHI" , _TL("Phi [degree]"), _TL("rotation around the Y axis (pitch)"), PARAMETER_TYPE_Double , 0.0 ); Parameters.Add_Value( pNode , "KAPPA" , _TL("Kappa [degree]"), _TL("rotation around the Z axis (heading)"), PARAMETER_TYPE_Double , 0.0 ); Parameters.Add_Value( pNode , "KAPPA_OFF" , _TL("Kappa Offset [degree]"), _TL("origin adjustment for Z axis (heading)"), PARAMETER_TYPE_Double , 90.0 ); //----------------------------------------------------- pNode = Parameters.Add_Node( NULL , "NODE_CAMERA" , _TL("Camera"), _TL("") ); Parameters.Add_Value( pNode , "CFL" , _TL("Focal Length [mm]"), _TL(""), PARAMETER_TYPE_Double , 80, 0.0, true ); Parameters.Add_Value( pNode , "PXSIZE" , _TL("CCD Physical Pixel Size [micron]"), _TL(""), PARAMETER_TYPE_Double , 5.2, 0.0, true ); //----------------------------------------------------- return( true ); }
bool CGPX2SHP::On_Execute(void) { CSG_String sCmd; CSG_String sFile = Parameters("FILE")->asString(); CSG_String sBasePath = Parameters("BASEPATH")->asString(); CSG_String sShapefile; bool bWaypoints = Parameters("WAYPOINTS")->asBool(); bool bTrackpoints = Parameters("TRACKPOINTS")->asBool(); bool bRoutes = Parameters("ROUTES")->asBool(); bool bAdd = Parameters("ADD")->asBool(); CSG_Shapes *pShapes; sCmd = sBasePath + SG_T("\\gpx2shp "); if (bWaypoints) { sCmd += SG_T("-w "); }//if if (bTrackpoints) { sCmd += SG_T("-t "); }//if if (bRoutes) { sCmd += SG_T("-r "); }//if sCmd += sFile; system(sCmd.b_str()); if( bAdd ) { CSG_String sDir(SG_File_Get_Path(sFile)), sName(SG_File_Get_Name(sFile, false)); //------------------------------------------------- sFile = SG_File_Make_Path(sDir, sName + SG_T("_wpt"), SG_T("shp")); pShapes = SG_Create_Shapes(sFile); if( pShapes->is_Valid() ) DataObject_Add(pShapes, false); else delete(pShapes); //------------------------------------------------- sFile = SG_File_Make_Path(sDir, sName + SG_T("_trk"), SG_T("shp")); pShapes = SG_Create_Shapes(sFile); if( pShapes->is_Valid() ) DataObject_Add(pShapes, false); else delete(pShapes); //------------------------------------------------- sFile = SG_File_Make_Path(sDir, sName + SG_T("_rte"), SG_T("shp")); pShapes = SG_Create_Shapes(sFile); if( pShapes->is_Valid() ) DataObject_Add(pShapes, false); else delete(pShapes); }//if return true; }//method
//--------------------------------------------------------- bool CGrid_Fill::On_Execute_Position(CSG_Point ptWorld, TSG_Module_Interactive_Mode Mode) { //----------------------------------------------------- if( Mode == MODULE_INTERACTIVE_LDOWN ) { int x, y, i, ix, iy, nReplaced; double z, zMin, zMax; x = Get_System()->Get_xWorld_to_Grid(ptWorld.Get_X()); y = Get_System()->Get_yWorld_to_Grid(ptWorld.Get_Y()); if( m_pGrid && m_pGrid->is_InGrid(x, y, m_bNoData) ) { Message_Add(_TL("Starting flood fill...")); switch( m_Method ) { case 0: z = m_pGrid->asDouble(x, y); break; // value at mouse position case 1: z = m_zFixed; break; // fixed value case 2: z = 0.0; break; // tolerance as absolute values } zMin = z + m_zTolerance_Min; zMax = z + m_zTolerance_Max; m_iStack = 0; nReplaced = 1; Push(x, y); //--------------------------------------------- while( m_iStack > 0 && Set_Progress(nReplaced, m_pGrid->Get_NCells()) ) { Pop(x, y); for(i=0; i<8; i+=2) { ix = Get_xTo(i, x); iy = Get_yTo(i, y); if( m_pGrid->is_InGrid(ix, iy, m_bNoData) ) { z = m_pGrid->asDouble(ix, iy); if( z != m_zFill && z >= zMin && z <= zMax ) { Push(ix, iy); m_pGrid->Set_Value(ix, iy, m_zFill); nReplaced++; } } } } //--------------------------------------------- Message_Add(_TL("ready"), false); Message_Add(CSG_String::Format(SG_T("%d %s"), nReplaced, _TL("replacements"))); DataObject_Update(m_pGrid, m_pGrid->Get_ZMin(), m_pGrid->Get_ZMax()); return( true ); } } return( false ); }
//--------------------------------------------------------- bool CACTIVE::Set_Active(CWKSP_Base_Item *pItem) { if( pItem == m_pItem ) { return( true ); } //----------------------------------------------------- m_pItem = pItem; if( m_pParameters ) m_pParameters->Set_Parameters(m_pItem); Update_Description(); STATUSBAR_Set_Text(SG_T(""), STATUSBAR_VIEW_X); STATUSBAR_Set_Text(SG_T(""), STATUSBAR_VIEW_Y); STATUSBAR_Set_Text(SG_T(""), STATUSBAR_VIEW_Z); //----------------------------------------------------- if( m_pItem == NULL ) { if( g_pSAGA_Frame ) g_pSAGA_Frame->Set_Pane_Caption(this, _TL("Properties")); if( g_pData_Buttons ) g_pData_Buttons->Refresh(); if( g_pMap_Buttons ) g_pMap_Buttons ->Refresh(); _Hide_Page(m_pHistory); _Hide_Page(m_pLegend); _Hide_Page(m_pAttributes); SendSizeEvent(); return( true ); } //----------------------------------------------------- if( g_pSAGA_Frame ) g_pSAGA_Frame->Set_Pane_Caption(this, wxString(_TL("Properties")) + ": " + m_pItem->Get_Name()); //----------------------------------------------------- if( Get_Active_Data_Item() ) { _Show_Page(m_pHistory ); } else { _Hide_Page(m_pHistory ); } if( Get_Active_Layer() || Get_Active_Map() ) { _Show_Page(m_pLegend ); } else { _Hide_Page(m_pLegend ); } if( Get_Active_Layer() ) { _Show_Page(m_pAttributes); } else { _Hide_Page(m_pAttributes); } //----------------------------------------------------- if( g_pData_Buttons ) g_pData_Buttons->Refresh(false); if( g_pMap_Buttons ) g_pMap_Buttons ->Refresh(false); if( g_pData_Source ) g_pData_Source->Set_Data_Source(m_pItem); //----------------------------------------------------- CSG_Data_Object *pObject = Get_Active_Data_Item() ? Get_Active_Data_Item()->Get_Object() : NULL; if( SG_Get_Data_Manager().Exists(pObject) && ( (pObject->Get_ObjectType() == DATAOBJECT_TYPE_Table && ((CSG_Table *)pObject)->Get_Selection_Count() > 0) || (pObject->Get_ObjectType() == DATAOBJECT_TYPE_TIN && ((CSG_Shapes *)pObject)->Get_Selection_Count() > 0) || (pObject->Get_ObjectType() == DATAOBJECT_TYPE_PointCloud && ((CSG_PointCloud *)pObject)->Get_Selection_Count() > 0) || (pObject->Get_ObjectType() == DATAOBJECT_TYPE_Shapes && ((CSG_Shapes *)pObject)->Get_Selection_Count() > 0)) ) { g_pData->Update_Views(pObject); } SendSizeEvent(); return( true ); }
bool CStreamNet::On_Execute(void) { // Inputs and Output Strings CSG_String InputBasename = CSG_String("input"); CSG_String OutputBasename = CSG_String("output"); CSG_String FEL_INPUT_FileName, FEL_INPUT_FilePath; CSG_String FLOWD8_INPUT_FileName, FLOWD8_INPUT_FilePath; CSG_String AREAD8_INPUT_FileName, AREAD8_INPUT_FilePath; CSG_String SRC_INPUT_FileName, SRC_INPUT_FilePath; CSG_String ORD_OUTPUT_FileName, ORD_OUTPUT_FilePath, ORD_OUTPUT_Name; CSG_String W_OUTPUT_FileName, W_OUTPUT_FilePath, W_OUTPUT_Name; CSG_String NET_OUTPUT_FileName, NET_OUTPUT_FilePath, NET_OUTPUT_Name; CSG_String TREE_OUTPUT_FileName, TREE_OUTPUT_FilePath, TREE_OUTPUT_Name; CSG_String COORD_OUTPUT_FileName, COORD_OUTPUT_FilePath, COORD_OUTPUT_Name; CSG_String OUTLET_INPUT_FileName, OUTLET_INPUT_FilePath; // Data Objects CSG_Grid *FEL_INPUT_Grid, *FLOWD8_INPUT_Grid, *SRC_INPUT_Grid, *AREAD8_INPUT_Grid, *ORD_OUTPUT_Grid, *W_OUTPUT_Grid; CSG_Shapes *OUTLET_INPUT_Shapes, *NET_OUTPUT_Shapes; CSG_Table *TREE_OUTPUT_Table, *COORD_OUTPUT_Table; // Misc TSG_Data_Type Type; CSG_String GDALDriver, sCmd, TempDirPath, TauDEMBinDir, BinaryName, BinaryPath, LogFile; CSG_Projection Projection; CSG_GDAL_DataSet DataSet; CSG_OGR_DataSource OGRDataSource; CSG_String OGRDriver = CSG_String("ESRI Shapefile"); bool sw; int nproc; // Grab inputs FEL_INPUT_Grid = Parameters("FEL_INPUT")->asGrid(); FLOWD8_INPUT_Grid = Parameters("FLOWD8_INPUT")->asGrid(); SRC_INPUT_Grid = Parameters("SRC_INPUT")->asGrid(); AREAD8_INPUT_Grid = Parameters("AREAD8_INPUT")->asGrid(); ORD_OUTPUT_Grid = Parameters("ORD_OUTPUT")->asGrid(); W_OUTPUT_Grid = Parameters("W_OUTPUT")->asGrid(); nproc = Parameters("NPROC")->asInt(); OUTLET_INPUT_Shapes = Parameters("OUTLET_INPUT")->asShapes(); NET_OUTPUT_Shapes = Parameters("NET_OUTPUT")->asShapes(); TREE_OUTPUT_Table = Parameters("TREE_OUTPUT")->asTable(); COORD_OUTPUT_Table = Parameters("COORD_OUTPUT")->asTable(); sw = Parameters("SW")->asBool(); GDALDriver = CSG_String("GTiff"); Get_Projection(Projection); Type = FEL_INPUT_Grid->Get_Type(); //TempDirPath = SG_File_Get_Path_Absolute(CSG_String("taudem_tmp")); TempDirPath = Parameters("TEMP_DIR")->asFilePath()->asString(); FEL_INPUT_FileName = InputBasename + CSG_String("fel"); FEL_INPUT_FilePath = SG_File_Make_Path(TempDirPath, FEL_INPUT_FileName, CSG_String("tif")); FLOWD8_INPUT_FileName = InputBasename + CSG_String("p"); FLOWD8_INPUT_FilePath = SG_File_Make_Path(TempDirPath, FLOWD8_INPUT_FileName, CSG_String("tif")); SRC_INPUT_FileName = InputBasename + CSG_String("src"); SRC_INPUT_FilePath = SG_File_Make_Path(TempDirPath, SRC_INPUT_FileName, CSG_String("tif")); AREAD8_INPUT_FileName = InputBasename + CSG_String("ad8"); AREAD8_INPUT_FilePath = SG_File_Make_Path(TempDirPath, AREAD8_INPUT_FileName, CSG_String("tif")); ORD_OUTPUT_FileName = OutputBasename + CSG_String("ord"); ORD_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, ORD_OUTPUT_FileName, CSG_String("tif")); ORD_OUTPUT_Name = CSG_String("NetworkOrder"); W_OUTPUT_FileName = OutputBasename + CSG_String("w"); W_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, W_OUTPUT_FileName, CSG_String("tif")); W_OUTPUT_Name = CSG_String("WatershedIDs"); OUTLET_INPUT_FileName = InputBasename + CSG_String("o"); OUTLET_INPUT_FilePath = SG_File_Make_Path(TempDirPath, OUTLET_INPUT_FileName, CSG_String("shp")); NET_OUTPUT_FileName = OutputBasename + CSG_String("net"); NET_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, NET_OUTPUT_FileName, CSG_String("shp")); NET_OUTPUT_Name = CSG_String("Channel Network"); TREE_OUTPUT_FileName = OutputBasename + CSG_String("tree"); TREE_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, TREE_OUTPUT_FileName, CSG_String("dat")); TREE_OUTPUT_Name = CSG_String("Channel Network Tree"); COORD_OUTPUT_FileName = OutputBasename + CSG_String("coord"); COORD_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, COORD_OUTPUT_FileName, CSG_String("dat")); COORD_OUTPUT_Name = CSG_String("Channel Network Coords"); LogFile = SG_File_Make_Path(TempDirPath, CSG_String("taudem_log.txt")); LogFile = SG_File_Get_Path_Absolute(LogFile); TauDEMBinDir = SG_File_Make_Path(CSG_String("bin"), CSG_String("TauDEM")); TauDEMBinDir = SG_File_Get_Path_Absolute(TauDEMBinDir); // options CSG_String OptionalFlags = CSG_String(""); if (OUTLET_INPUT_Shapes != NULL) { OptionalFlags = CSG_String::Format(SG_T("-o \"%s\" "), OUTLET_INPUT_FilePath.c_str()); } if (sw) { OptionalFlags = OptionalFlags + CSG_String::Format(SG_T("-sw")); } // exec commnad BinaryName = CSG_String("StreamNet"); // D8 BinaryPath = SG_File_Make_Path(TauDEMBinDir, BinaryName); sCmd = CSG_String::Format(SG_T("\"mpiexec -n %d \"%s\" -fel \"%s\" -p \"%s\" -ad8 \"%s\" -src \"%s\" -ord \"%s\" -tree \"%s\" -coord \"%s\" -net \"%s\" -w \"%s\" %s >\"%s\" 2>&1\""), nproc, BinaryPath.c_str(), FEL_INPUT_FilePath.c_str(), FLOWD8_INPUT_FilePath.c_str(), AREAD8_INPUT_FilePath.c_str(), SRC_INPUT_FilePath.c_str(), ORD_OUTPUT_FilePath.c_str(), TREE_OUTPUT_FilePath.c_str(), COORD_OUTPUT_FilePath.c_str(), NET_OUTPUT_FilePath.c_str(), W_OUTPUT_FilePath.c_str(), OptionalFlags.c_str(), LogFile.c_str()); // make sure temp dir exists if (!SG_Dir_Exists(TempDirPath)) { if (!SG_Dir_Create(TempDirPath)) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to create temp directory"), TempDirPath.c_str())); } } CSG_String FilePaths [10] = {FEL_INPUT_FilePath, FLOWD8_INPUT_FilePath, SRC_INPUT_FilePath, AREAD8_INPUT_FilePath, ORD_OUTPUT_FilePath, W_OUTPUT_FilePath, OUTLET_INPUT_FilePath, NET_OUTPUT_FilePath, TREE_OUTPUT_FilePath, COORD_OUTPUT_FilePath}; for (int i = 0; i < 10; i++) { CSG_String FilePath = FilePaths[i]; // Delete old file if exists if (SG_File_Exists(FilePath)) { if (!SG_File_Delete(FilePath)) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete existing file: "), FilePath.c_str())); return( false ); } } } // SAVE TIFFS CSG_String TIFF_INPUT_FilePaths [4] = {FEL_INPUT_FilePath, FLOWD8_INPUT_FilePath, SRC_INPUT_FilePath, AREAD8_INPUT_FilePath}; CSG_Grid* TIFF_INPUT_Grids [4] = {FEL_INPUT_Grid, FLOWD8_INPUT_Grid, SRC_INPUT_Grid, AREAD8_INPUT_Grid}; for (int i = 0; i < 4; i++) { CSG_String FilePath = TIFF_INPUT_FilePaths[i]; CSG_Grid* Grid = TIFF_INPUT_Grids[i]; if( !DataSet.Open_Write(FilePath, GDALDriver, CSG_String(""), Type, 1, *Get_System(), Projection) ) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), FilePath.c_str())); return( false ); } DataSet.Write(0, Grid); if( !DataSet.Close() ) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to close file after writing: "), FilePath.c_str())); return( false ); } } if (OUTLET_INPUT_Shapes != NULL) { // save outlet shapefile CSG_String OGRDriver = CSG_String("ESRI Shapefile"); if( !OGRDataSource.Create(OUTLET_INPUT_FilePath, OGRDriver) ) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), OUTLET_INPUT_FilePath.c_str())); return( false ); } OGRDataSource.Write(OUTLET_INPUT_Shapes, OGRDriver); OGRDataSource.Destroy(); } // Run TauDEM StreamNet Message_Add(CSG_String("Executing ") + sCmd); if (system(sCmd.b_str()) != 0) { Error_Set(CSG_String::Format(SG_T("Error executing '%s' see Execution log for details"), BinaryName.c_str())); // read log output CSG_File File; if (File.Open(LogFile, SG_FILE_R, false)) { CSG_String Line; while (! File.is_EOF() && File.Read_Line(Line)) { Message_Add(Line); } File.Close(); } else { Message_Add(CSG_String("Unable to open " + LogFile + CSG_String(" for reading"))); } return( false ); } // Load output tiffs if( !DataSet.Open_Read(ORD_OUTPUT_FilePath)) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open output file: "), ORD_OUTPUT_FilePath.c_str())); return( false ); } else { ORD_OUTPUT_Grid->Assign(DataSet.Read(0)); ORD_OUTPUT_Grid->Set_Name(ORD_OUTPUT_Name); Parameters("ORD_OUTPUT")->Set_Value(ORD_OUTPUT_Grid); } if( !DataSet.Open_Read(W_OUTPUT_FilePath)) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open output file: "), W_OUTPUT_FilePath.c_str())); return( false ); } else { W_OUTPUT_Grid->Assign(DataSet.Read(0)); W_OUTPUT_Grid->Set_Name(W_OUTPUT_Name); Parameters("W_OUTPUT")->Set_Value(W_OUTPUT_Grid); CSG_Colors colors; DataObject_Get_Colors(SRC_INPUT_Grid, colors); DataObject_Set_Colors(ORD_OUTPUT_Grid, colors); DataObject_Update(ORD_OUTPUT_Grid, false); } // load output shapefile if( !OGRDataSource.Create(NET_OUTPUT_FilePath) ) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for reading: "), NET_OUTPUT_FilePath.c_str())); return( false ); } NET_OUTPUT_Shapes->Assign(OGRDataSource.Read(0, 0)); NET_OUTPUT_Shapes->Set_Name(NET_OUTPUT_Name); OGRDataSource.Destroy(); // load table data if (!SG_File_Exists(COORD_OUTPUT_FilePath)) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Output file does not exist: "), COORD_OUTPUT_FilePath.c_str())); return false; } else { COORD_OUTPUT_Table->Destroy(); COORD_OUTPUT_Table->Set_Name(COORD_OUTPUT_Name); // create table fields COORD_OUTPUT_Table->Add_Field(SG_T("X"), SG_DATATYPE_Double); COORD_OUTPUT_Table->Add_Field(SG_T("Y"), SG_DATATYPE_Double); COORD_OUTPUT_Table->Add_Field(SG_T("Terminal Distance"), SG_DATATYPE_Double); COORD_OUTPUT_Table->Add_Field(SG_T("Elevation"), SG_DATATYPE_Double); COORD_OUTPUT_Table->Add_Field(SG_T("Contributing Area"), SG_DATATYPE_Double); // read table data CSG_File File; if (File.Open(COORD_OUTPUT_FilePath, SG_FILE_R, false)) { CSG_String Line; // determine number of lines while (! File.is_EOF() && File.Read_Line(Line)) { Line.Trim(); if (Line.Length() == 0) { break; } else { CSG_Table_Record *Record = COORD_OUTPUT_Table->Add_Record(); for (int i = 0; i < COORD_OUTPUT_Table->Get_Field_Count(); i++) { Record->Set_Value(i, Line.asDouble()); Line = Line.AfterFirst('\t'); Line.Trim(); } } } File.Close(); } else { Message_Add(CSG_String("Unable to open " + COORD_OUTPUT_FilePath + CSG_String(" for reading"))); } } if (!SG_File_Exists(TREE_OUTPUT_FilePath)) { Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Output file does not exist: "), TREE_OUTPUT_FilePath.c_str())); return false; } else { TREE_OUTPUT_Table->Destroy(); TREE_OUTPUT_Table->Set_Name(TREE_OUTPUT_Name); // create table fields TREE_OUTPUT_Table->Add_Field(SG_T("Link"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("Start Point"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("End Point"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("Next (Downstream) Link"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("First Previous (Upstream) Link"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("Second Previous (Upstream) Link"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("Strahler Order"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("Monitoring Point ID"), SG_DATATYPE_Int); TREE_OUTPUT_Table->Add_Field(SG_T("Link Network Magnitude"), SG_DATATYPE_Int); // read table data CSG_File File; if (File.Open(TREE_OUTPUT_FilePath, SG_FILE_R, false)) { CSG_String Line; // determine number of lines while (! File.is_EOF() && File.Read_Line(Line)) { Line.Trim(); if (Line.Length() == 0) { break; } else { CSG_Table_Record *Record = TREE_OUTPUT_Table->Add_Record(); for (int i = 0; i < TREE_OUTPUT_Table->Get_Field_Count(); i++) { Record->Set_Value(i, Line.asDouble()); Line = Line.AfterFirst('\t'); Line.Trim(); } } } File.Close(); } else { Message_Add(CSG_String("Unable to open " + TREE_OUTPUT_FilePath + CSG_String(" for reading"))); } } return( true ); }
//--------------------------------------------------------- bool CGPS_Track_Aggregation::On_Execute(void) { bool bVerbose, bPolar; int Time_Span, fRefID, fX, fY, fTrack, fDate, fTime, fParameter, Observation, iDropped, nDropped; double eps_Space, eps_Time, off_Time, iTime; TSG_Point Position; CSG_String iTrack, iDate; CSG_Table_Record *pAggregate, *pObservation; CSG_Shape *pReference, *pNearest; CSG_Simple_Statistics Statistic, Time; CSG_Table *pObservations, *pAggregated, Observations; CSG_Shapes_Search Reference; //----------------------------------------------------- pObservations = Parameters("OBSERVATIONS") ->asTable (); pAggregated = Parameters("AGGREGATED") ->asTable (); fRefID = Parameters("REFERENCE_ID") ->asInt (); fX = Parameters("X") ->asInt (); fY = Parameters("Y") ->asInt (); fTrack = Parameters("TRACK") ->asInt (); fDate = Parameters("DATE") ->asInt (); fTime = Parameters("TIME") ->asInt (); fParameter = Parameters("PARAMETER") ->asInt (); Time_Span = Parameters("TIME_SPAN") ->asInt (); eps_Space = Parameters("EPS_SPACE") ->asDouble(); off_Time = Parameters("OFF_TIME") ->asDouble() * 60.0; bVerbose = Parameters("VERBOSE") ->asBool (); bPolar = Parameters("POLAR") ->asBool (); switch( Time_Span ) { default: eps_Time = 0.0; break; case 1: eps_Time = Parameters("EPS_TIME")->asDouble(); break; case 2: eps_Time = Parameters("FIX_TIME")->asDouble() * 60.0; break; } if( eps_Time <= 0.0 ) { Time_Span = 0; } //----------------------------------------------------- if( !Reference.Create(Parameters("REFERENCE")->asShapes()) ) { Error_Set(_TL("could not initialize reference point search engine")); return( false ); } //----------------------------------------------------- if( Time_Span == 2 ) // pre-processing for 'fix' time span { Observations.Create(*pObservations); Observations.Add_Field(SG_T("REF_ID"), SG_DATATYPE_String); fTrack = pObservations->Get_Field_Count(); pObservations = &Observations; for(Observation=0; Observation<pObservations->Get_Count() && Set_Progress(Observation, pObservations->Get_Count()); Observation++) { pObservation = pObservations->Get_Record(Observation); pNearest = Reference.Get_Point_Nearest(pObservation->asDouble(fX), pObservation->asDouble(fY)); pObservation ->Set_Value(fTrack, pNearest->asString(fRefID)); } } //----------------------------------------------------- if( !pObservations->Set_Index(fTrack, TABLE_INDEX_Ascending, fDate, TABLE_INDEX_Ascending, fTime, TABLE_INDEX_Ascending) ) { Error_Set(_TL("could not create index on observations")); return( false ); } //----------------------------------------------------- pAggregated->Destroy(); pAggregated->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pObservations->Get_Name(), _TL("aggregated"))); pAggregated->Add_Field(SG_T("REFID") , SG_DATATYPE_String); // AGG_ID pAggregated->Add_Field(SG_T("TRACK") , SG_DATATYPE_String); // AGG_TRACK pAggregated->Add_Field(SG_T("DATE") , SG_DATATYPE_String); // AGG_DATE pAggregated->Add_Field(SG_T("TIME") , SG_DATATYPE_String); // AGG_TIME pAggregated->Add_Field(pObservations->Get_Field_Name(fParameter), SG_DATATYPE_Double); // AGG_PARM if( bVerbose ) { pAggregated->Add_Field(SG_T("MIN") , SG_DATATYPE_Double); // AGG_MIN, pAggregated->Add_Field(SG_T("MAX") , SG_DATATYPE_Double); // AGG_MAX pAggregated->Add_Field(SG_T("RANGE") , SG_DATATYPE_Double); // AGG_RANGE pAggregated->Add_Field(SG_T("STDDEV") , SG_DATATYPE_Double); // AGG_STDDEV, pAggregated->Add_Field(SG_T("COUNT") , SG_DATATYPE_Int ); // AGG_COUNT, pAggregated->Add_Field(SG_T("DROPPED") , SG_DATATYPE_Int ); // AGG_DROPPED, pAggregated->Add_Field(SG_T("DTIME") , SG_DATATYPE_Double); // AGG_DTIME, pAggregated->Add_Field(SG_T("X") , SG_DATATYPE_Double); // AGG_X pAggregated->Add_Field(SG_T("Y") , SG_DATATYPE_Double); // AGG_Y } //----------------------------------------------------- pAggregate = NULL; nDropped = 0; iDropped = 0; //----------------------------------------------------- for(Observation=0; Observation<pObservations->Get_Count() && Set_Progress(Observation, pObservations->Get_Count()); Observation++) { pObservation = pObservations->Get_Record_byIndex(Observation); if( !pAggregate || iTrack.Cmp(pObservation->asString(fTrack)) || iDate .Cmp(pObservation->asString(fDate )) || (eps_Time > 0.0 && eps_Time <= pObservation->asDouble(fTime) - iTime) ) { pReference = NULL; } Position.x = pObservation->asDouble(fX); Position.y = pObservation->asDouble(fY); pNearest = Reference.Get_Point_Nearest(Position.x, Position.y); if( eps_Space > 0.0 && eps_Space <= (bPolar ? SG_Get_Distance_Polar(Position, pNearest->Get_Point(0)) : SG_Get_Distance(Position, pNearest->Get_Point(0))) ) { nDropped++; iDropped++; } else { if( pReference != pNearest ) { Set_Statistic(pAggregate, Statistic, Time, iDropped, bVerbose); Statistic .Invalidate(); Time .Invalidate(); iDropped = 0; iTrack = pObservation->asString(fTrack); iDate = pObservation->asString(fDate ); switch( Time_Span ) { default: iTime = 0.0; break; case 1: iTime = pObservation->asDouble(fTime); break; case 2: iTime = (int)(pObservation->asDouble(fTime) / eps_Time) * eps_Time - off_Time; break; } pReference = pNearest; pAggregate = pAggregated->Add_Record(); pAggregate ->Set_Value(AGG_ID , pReference->asString(fRefID)); pAggregate ->Set_Value(AGG_TRACK, iTrack); pAggregate ->Set_Value(AGG_DATE , iDate ); if( bVerbose ) { pAggregate ->Set_Value(AGG_X, pReference->Get_Point(0).x); pAggregate ->Set_Value(AGG_Y, pReference->Get_Point(0).y); } } Statistic += pObservation->asDouble(fParameter); Time += pObservation->asDouble(fTime ); } } Set_Statistic(pAggregate, Statistic, Time, iDropped, bVerbose); //----------------------------------------------------- if( nDropped > 0 ) { Message_Add(CSG_String::Format(SG_T("%s: %d"), _TL("number of dropped observations"), nDropped)); } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CFilter_3x3::On_Execute(void) { bool bAbsolute; CSG_Matrix Filter; CSG_Grid *pInput, *pResult; CSG_Table *pFilter; //----------------------------------------------------- pInput = Parameters("INPUT" )->asGrid(); pResult = Parameters("RESULT" )->asGrid(); bAbsolute = Parameters("ABSOLUTE" )->asBool(); pFilter = Parameters("FILTER" )->asTable() ? Parameters("FILTER" )->asTable() : Parameters("FILTER_3X3")->asTable(); if( pFilter->Get_Count() < 1 || pFilter->Get_Field_Count() < 1 ) { Error_Set(_TL("invalid filter matrix")); return( false ); } //----------------------------------------------------- Filter.Create(pFilter->Get_Field_Count(), pFilter->Get_Count()); { for(int iy=0; iy<Filter.Get_NY(); iy++) { CSG_Table_Record *pRecord = pFilter->Get_Record(iy); for(int ix=0; ix<Filter.Get_NX(); ix++) { Filter[iy][ix] = pRecord->asDouble(ix); } } } int dx = (Filter.Get_NX() - 1) / 2; int dy = (Filter.Get_NY() - 1) / 2; //----------------------------------------------------- if( !pResult || pResult == pInput ) { pResult = SG_Create_Grid(pInput); } else { pResult->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pInput->Get_Name(), _TL("Filter"))); pResult->Set_NoData_Value(pInput->Get_NoData_Value()); } //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { double s = 0.0; double n = 0.0; if( pInput->is_InGrid(x, y) ) { for(int iy=0, jy=y-dy; iy<Filter.Get_NY(); iy++, jy++) { for(int ix=0, jx=x-dx; ix<Filter.Get_NX(); ix++, jx++) { if( pInput->is_InGrid(jx, jy) ) { s += Filter[iy][ix] * pInput->asDouble(jx, jy); n += fabs(Filter[iy][ix]); } } } } if( n > 0.0 ) { pResult->Set_Value(x, y, bAbsolute ? s : s / n); } else { pResult->Set_NoData(x, y); } } } //----------------------------------------------------- if( !Parameters("RESULT")->asGrid() || Parameters("RESULT")->asGrid() == pInput ) { pInput->Assign(pResult); delete(pResult); DataObject_Update(pInput); } return( true ); }
//--------------------------------------------------------- CGPS_Track_Aggregation::CGPS_Track_Aggregation(void) { CSG_Parameter *pNode; //----------------------------------------------------- // 1. Info... Set_Name (_TL("Aggregate Point Observations")); Set_Author (SG_T("O.Conrad (c) 2011")); Set_Description (_TW( "" )); //----------------------------------------------------- // 2. Parameters... pNode = Parameters.Add_Shapes( NULL , "REFERENCE" , _TL("Reference Points"), _TL(""), PARAMETER_INPUT, SHAPE_TYPE_Point ); Parameters.Add_Table_Field( pNode , "REFERENCE_ID" , _TL("ID"), _TL("") ); pNode = Parameters.Add_Table( NULL , "OBSERVATIONS" , _TL("Observations"), _TL(""), PARAMETER_INPUT ); Parameters.Add_Table_Field( pNode , "X" , _TL("X"), _TL("") ); Parameters.Add_Table_Field( pNode , "Y" , _TL("Y"), _TL("") ); Parameters.Add_Table_Field( pNode , "TRACK" , _TL("Track"), _TL("") ); Parameters.Add_Table_Field( pNode , "DATE" , _TL("Date"), _TL("") ); Parameters.Add_Table_Field( pNode , "TIME" , _TL("Time"), _TL("expected to be the second of day") ); Parameters.Add_Table_Field( pNode , "PARAMETER" , _TL("Parameter"), _TL("") ); Parameters.Add_Table( NULL , "AGGREGATED" , _TL("Aggregated"), _TL(""), PARAMETER_OUTPUT ); Parameters.Add_Choice( NULL , "TIME_SPAN" , _TL("Time Span Aggregation"), _TL(""), CSG_String::Format(SG_T("%s|%s|%s|"), _TL("ignore"), _TL("floating"), _TL("fixed") ), 1 ); Parameters.Add_Value( NULL , "FIX_TIME" , _TL("Fixed Time Span (minutes)"), _TL("ignored if set to zero"), PARAMETER_TYPE_Double, 20.0, 0.0, true ); Parameters.Add_Value( NULL , "OFF_TIME" , _TL("Fixed Time Span Offset (minutes)"), _TL("offset in minutes relative to 00:00 (midnight)"), PARAMETER_TYPE_Double, -10.0 ); Parameters.Add_Value( NULL , "EPS_TIME" , _TL("Maximum Time Span (Seconds)"), _TL("ignored if set to zero"), PARAMETER_TYPE_Double, 60.0, 0.0, true ); Parameters.Add_Value( NULL , "EPS_SPACE" , _TL("Maximum Distance"), _TL("given as map units or meters if polar coordinates switch is on; ignored if set to zero"), PARAMETER_TYPE_Double, 100.0, 0.0, true ); Parameters.Add_Value( NULL , "VERBOSE" , _TL("Verbose"), _TL(""), PARAMETER_TYPE_Bool, false ); Parameters.Add_Value( NULL , "POLAR" , _TL("Polar Coordinates"), _TL(""), PARAMETER_TYPE_Bool, false ); }
//--------------------------------------------------------- CGCS_Graticule::CGCS_Graticule(void) { CSG_Parameter *pNode_0, *pNode_1; //----------------------------------------------------- Set_Name (_TL("Latitude/Longitude Graticule")); Set_Author (SG_T("O. Conrad (c) 2014")); Set_Description (_TW( "Creates a longitude/latitude graticule for the extent and projection of the input shapes layer. " )); Set_Description (Get_Description() + "\n" + CSG_CRSProjector::Get_Description()); //----------------------------------------------------- Parameters.Add_Shapes( NULL , "GRATICULE" , _TL("Graticule"), _TL(""), PARAMETER_OUTPUT, SHAPE_TYPE_Line ); Parameters.Add_Shapes( NULL , "COORDS" , _TL("Frame Coordinates"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, SHAPE_TYPE_Point ); pNode_0 = Parameters.Add_Node( NULL , "NODE_GRID" , _TL("Graticule"), _TL("") ); pNode_1 = Parameters.Add_Node(pNode_0, "NODE_X" , _TL("X Range"), _TL("")); Parameters.Add_Value(pNode_1, "XMIN", _TL("Minimum"), _TL(""), PARAMETER_TYPE_Double); Parameters.Add_Value(pNode_1, "XMAX", _TL("Maximum"), _TL(""), PARAMETER_TYPE_Double); pNode_1 = Parameters.Add_Node(pNode_0, "NODE_Y" , _TL("Y Range"), _TL("")); Parameters.Add_Value(pNode_1, "YMIN", _TL("Minimum"), _TL(""), PARAMETER_TYPE_Double); Parameters.Add_Value(pNode_1, "YMAX", _TL("Maximum"), _TL(""), PARAMETER_TYPE_Double); Parameters.Add_Choice( pNode_0 , "INTERVAL" , _TL("Interval"), _TL(""), CSG_String::Format(SG_T("%s|%s|"), _TL("fixed interval"), _TL("fitted interval") ), 0 ); Parameters.Add_Value( pNode_0 , "FIXED" , _TL("Fixed Interval (Degree)"), _TL(""), PARAMETER_TYPE_Double, 1.0, 0.0, true, 20.0 ); Parameters.Add_Value( pNode_0 , "FITTED" , _TL("Number of Intervals"), _TL(""), PARAMETER_TYPE_Int, 10, 1, true ); Parameters.Add_Value( pNode_0 , "RESOLUTION" , _TL("Minimum Resolution (Degree)"), _TL(""), PARAMETER_TYPE_Double, 0.5, 0.0, true ); }
//--------------------------------------------------------- CD8_Flow_Analysis::CD8_Flow_Analysis(void) { //----------------------------------------------------- Set_Name (_TL("Channel Network and Drainage Basins")); Set_Author (SG_T("O.Conrad (c) 2003")); Set_Description (_TW( "Deterministic 8 based flow network analysis\n" )); //----------------------------------------------------- Parameters.Add_Grid( NULL , "DEM" , _TL("Elevation"), _TL(""), PARAMETER_INPUT ); Parameters.Add_Grid( NULL , "DIRECTION" , _TL("Flow Direction"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, true, SG_DATATYPE_Char ); Parameters.Add_Grid( NULL , "CONNECTION" , _TL("Flow Connectivity"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, true, SG_DATATYPE_Char ); Parameters.Add_Grid( NULL , "ORDER" , _TL("Strahler Order"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, true, SG_DATATYPE_Short ); Parameters.Add_Grid( NULL , "BASIN" , _TL("Drainage Basins"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, true, SG_DATATYPE_Short ); Parameters.Add_Shapes( NULL , "SEGMENTS" , _TL("Channels"), _TL(""), PARAMETER_OUTPUT, SHAPE_TYPE_Line ); Parameters.Add_Shapes( NULL , "BASINS" , _TL("Drainage Basins"), _TL(""), PARAMETER_OUTPUT, SHAPE_TYPE_Polygon ); Parameters.Add_Shapes( NULL , "NODES" , _TL("Junctions"), _TL(""), PARAMETER_OUTPUT_OPTIONAL, SHAPE_TYPE_Point ); Parameters.Add_Value( NULL , "THRESHOLD" , _TL("Threshold"), _TL("Strahler order to begin a channel."), PARAMETER_TYPE_Int, 5, 1, true ); }