//--------------------------------------------------------- bool CLandsat_Import::On_Execute(void) { CSG_Strings Files; if( !Parameters("FILES")->asFilePath()->Get_FilePaths(Files) || Files.Get_Count() <= 0 ) { return( false ); } //----------------------------------------------------- CSG_Parameter_Grid_List *pBands = Parameters("BANDS")->asGridList(); pBands->Del_Items(); for(int i=0; i<Files.Get_Count(); i++) { Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("loading"), SG_File_Get_Name(Files[i], false).c_str())); CSG_Grid *pBand = Get_Band(Files[i]); if( pBand ) { pBands->Add_Item(pBand); DataObject_Add(pBand); DataObject_Set_Colors(pBand, 11, SG_COLORS_BLACK_WHITE); } } //----------------------------------------------------- if( Parameters("SHOW_RGB")->is_Enabled() && Parameters("SHOW_RGB")->asBool() ) { CSG_Grid *pR = pBands->asGrid(Parameters("SHOW_R")->asInt()); CSG_Grid *pG = pBands->asGrid(Parameters("SHOW_G")->asInt()); CSG_Grid *pB = pBands->asGrid(Parameters("SHOW_B")->asInt()); if( pR && pG && pB ) { DataObject_Set_Parameter(pR, "COLORS_TYPE" , 5); // _TL("RGB Overlay") // CLASSIFY_OVERLAY DataObject_Set_Parameter(pR, "OVERLAY_MODE", 0); // _TL("red=this, green=1, blue=2") DataObject_Set_Parameter(pR, "OVERLAY_G" , pG); DataObject_Set_Parameter(pR, "OVERLAY_B" , pB); DataObject_Update(pR, true); } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CPanSharp_PCA::On_Execute(void) { //----------------------------------------------------- bool bResult; CSG_Parameters Tool_Parms; CSG_Table Eigen; //----------------------------------------------------- // get the principal components for the low resolution bands SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 8, Tool_Parms, SG_TOOL_PARAMETER_SET("GRIDS" , Parameters("GRIDS" )) && SG_TOOL_PARAMETER_SET("METHOD" , Parameters("METHOD")) && SG_TOOL_PARAMETER_SET("EIGEN" , &Eigen) && SG_TOOL_PARAMETER_SET("COMPONENTS", 0) // get all components ); if( !bResult ) { return( false ); } //----------------------------------------------------- CSG_Parameter_Grid_List *pPCA = Tool_Parms.Get_Parameter("PCA")->asGridList(); int i, n = pPCA->Get_Grid_Count(); CSG_Grid *PCA = new CSG_Grid[n]; CSG_Grid *pPan = Parameters("PAN")->asGrid(); //----------------------------------------------------- // replace first principal component with the high resolution panchromatic band Process_Set_Text(_TL("Replace first PC with PAN")); double Offset_Pan, Offset, Scale; if( Parameters("PAN_MATCH")->asInt() == 0 ) // scale PAN band to fit first PC histogram { Offset_Pan = pPan->Get_Min(); Offset = pPCA->Get_Grid(0)->Get_Min(); Scale = pPCA->Get_Grid(0)->Get_Range() / pPan->Get_Range(); } else { Offset_Pan = pPan->Get_Mean(); Offset = pPCA->Get_Grid(0)->Get_Mean(); Scale = pPCA->Get_Grid(0)->Get_StdDev() / pPan->Get_StdDev(); } PCA[0].Create(Get_System()); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { if( pPan->is_NoData(x, y) ) { PCA[0].Set_NoData(x, y); } else { PCA[0].Set_Value(x, y, Offset + Scale * (pPan->asDouble(x, y) - Offset_Pan)); } } } //----------------------------------------------------- // resample all other PCs to match the high resolution of the PAN band TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt()); for(i=1; i<n; i++) { Process_Set_Text("%s: %s ...", _TL("Resampling"), pPCA->Get_Grid(i)->Get_Name()); PCA[i].Create(Get_System()); PCA[i].Assign(pPCA->Get_Grid(i), Resampling); delete(pPCA->Get_Grid(i)); // PCA tool was unmanaged, so we have to delete the output } delete(pPCA->Get_Grid(0)); pPCA->Del_Items(); for(i=0; i<n; i++) { pPCA->Add_Item(&PCA[i]); } //----------------------------------------------------- // inverse principal component rotation for the high resolution bands SG_RUN_TOOL_KEEP_PARMS(bResult, "statistics_grid", 10, Tool_Parms, SG_TOOL_PARAMETER_SET("PCA" , Tool_Parms("PCA")) && SG_TOOL_PARAMETER_SET("GRIDS", Parameters("SHARPEN")) && SG_TOOL_PARAMETER_SET("EIGEN", &Eigen) ); delete[](PCA); if( !bResult ) { return( false ); } CSG_Parameter_Grid_List *pHiRes = Parameters("SHARPEN")->asGridList(); CSG_Parameter_Grid_List *pLoRes = Parameters("GRIDS" )->asGridList(); CSG_Parameter_Grid_List *pGrids = Tool_Parms("GRIDS" )->asGridList(); if( !Parameters("OVERWRITE")->asBool() ) { pHiRes->Del_Items(); } for(i=0; i<pLoRes->Get_Grid_Count() && i<pGrids->Get_Grid_Count(); i++) { if( pHiRes->Get_Grid(i) ) { pHiRes->Get_Grid(i)->Assign(pGrids->Get_Grid(i)); delete(pGrids->Get_Grid(i)); } else { pHiRes->Add_Item(pGrids->Get_Grid(i)); } pHiRes->Get_Grid(i)->Set_Name(pLoRes->Get_Grid(i)->Get_Name()); } return( true ); }
//--------------------------------------------------------- bool CPanSharp_CN::On_Execute(void) { //----------------------------------------------------- TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt()); //----------------------------------------------------- int i; CSG_Grid *pPan = Parameters("PAN")->asGrid(); CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS" )->asGridList(); CSG_Parameter_Grid_List *pSharp = Parameters("SHARPEN")->asGridList(); //----------------------------------------------------- pSharp->Del_Items(); for(i=0; i<pGrids->Get_Grid_Count(); i++) { Process_Set_Text("%s: %s ...", _TL("Resampling"), pGrids->Get_Grid(i)->Get_Name()); CSG_Grid *pGrid = SG_Create_Grid(Get_System()); pGrid->Set_Name (pGrids->Get_Grid(i)->Get_Name()); pGrid->Assign (pGrids->Get_Grid(i), Resampling); pSharp->Add_Item(pGrid); } //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for private(i) for(int x=0; x<Get_NX(); x++) { double Sum = 0.0; if( !pPan->is_NoData(x, y) ) { for(i=0; i<pSharp->Get_Grid_Count(); i++) { if( !pSharp->Get_Grid(i)->is_NoData(x, y) ) { Sum += pSharp->Get_Grid(i)->asDouble(x, y); } else { Sum = 0.0; break; } } } if( Sum ) { Sum = pPan->asDouble(x, y) * pSharp->Get_Grid_Count() / (Sum + pSharp->Get_Grid_Count()); for(i=0; i<pSharp->Get_Grid_Count(); i++) { pSharp->Get_Grid(i)->Mul_Value(x, y, Sum); } } else { for(i=0; i<pSharp->Get_Grid_Count(); i++) { pSharp->Get_Grid(i)->Set_NoData(x, y); } } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CDirect_Georeferencing::On_Execute(void) { //----------------------------------------------------- if( !m_Georeferencer.Set_Transformation(Parameters, Get_NX(), Get_NY()) ) { return( false ); } //----------------------------------------------------- CSG_Grid *pDEM = Parameters("DEM" )->asGrid(); double zRef = Parameters("ZREF" )->asDouble(); bool bFlip = Parameters("ROW_ORDER")->asInt() == 1; //----------------------------------------------------- TSG_Grid_Resampling Resampling; switch( Parameters("RESAMPLING")->asInt() ) { default: Resampling = GRID_RESAMPLING_NearestNeighbour; break; case 1: Resampling = GRID_RESAMPLING_Bilinear; break; case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break; case 3: Resampling = GRID_RESAMPLING_BSpline; break; } //----------------------------------------------------- TSG_Point p[4]; p[0] = m_Georeferencer.Image_to_World( 0, 0, zRef); p[1] = m_Georeferencer.Image_to_World(Get_NX(), 0, zRef); p[2] = m_Georeferencer.Image_to_World(Get_NX(), Get_NY(), zRef); p[3] = m_Georeferencer.Image_to_World( 0, Get_NY(), zRef); CSG_Rect r(p[0], p[1]); r.Union(p[2]); r.Union(p[3]); //----------------------------------------------------- CSG_Shapes *pShapes = Parameters("EXTENT")->asShapes(); if( pShapes ) { pShapes->Create(SHAPE_TYPE_Polygon, _TL("Extent")); pShapes->Add_Field(_TL("OID"), SG_DATATYPE_Int); CSG_Shape *pExtent = pShapes->Add_Shape(); pExtent->Add_Point(p[0]); pExtent->Add_Point(p[1]); pExtent->Add_Point(p[2]); pExtent->Add_Point(p[3]); } //----------------------------------------------------- double Cellsize = SG_Get_Distance(p[0], p[1]) / Get_NX(); CSG_Grid_System System(Cellsize, r); m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), r, Get_NX()); if( !Dlg_Parameters("TARGET") ) { return( false ); } System = m_Grid_Target.Get_System(); if( !System.is_Valid() ) { return( false ); } //----------------------------------------------------- CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList(); CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList(); pOutput->Del_Items(); if( pInput->Get_Count() <= 0 ) { return( false ); } else { TSG_Data_Type Type; switch( Parameters("DATA_TYPE")->asInt() ) { case 0: Type = SG_DATATYPE_Byte; break; case 1: Type = SG_DATATYPE_Char; break; case 2: Type = SG_DATATYPE_Word; break; case 3: Type = SG_DATATYPE_Short; break; case 4: Type = SG_DATATYPE_DWord; break; case 5: Type = SG_DATATYPE_Int; break; case 6: Type = SG_DATATYPE_Float; break; case 7: Type = SG_DATATYPE_Double; break; default: Type = SG_DATATYPE_Undefined; break; } for(int i=0; i<pInput->Get_Count(); i++) { CSG_Grid *pGrid = SG_Create_Grid(System, Type != SG_DATATYPE_Undefined ? Type : pInput->asGrid(i)->Get_Type()); if( !pGrid || !pGrid->is_Valid() ) { if( pGrid ) { delete(pGrid); } return( false ); } pOutput->Add_Item(pGrid); pGrid->Set_Name(pInput->asGrid(i)->Get_Name()); } } //----------------------------------------------------- for(int y=0; y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++) { double py = System.Get_YMin() + y * System.Get_Cellsize(); #pragma omp parallel for for(int x=0; x<System.Get_NX(); x++) { double pz, px = System.Get_XMin() + x * System.Get_Cellsize(); if( !pDEM || !pDEM->Get_Value(px, py, pz) ) { pz = zRef; } TSG_Point p = m_Georeferencer.World_to_Image(px, py, pz); if( bFlip ) { p.y = (Get_NY() - 1) - p.y; } for(int i=0; i<pInput->Get_Count(); i++) { if( pInput->asGrid(i)->Get_Value(p.x, p.y, pz, Resampling) ) { pOutput->asGrid(i)->Set_Value(x, y, pz); } else { pOutput->asGrid(i)->Set_NoData(x, y); } } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGridsFromTableAndGrid::On_Execute(void) { int iField, iRecord, iAttribute, nAttributes, *Attribute; sLong iCell, jCell; CSG_Parameter_Grid_List *pGrids; CSG_Grid *pClasses; CSG_Table *pTable; //----------------------------------------------------- pClasses = Parameters("CLASSES" )->asGrid(); pGrids = Parameters("GRIDS" )->asGridList(); pTable = Parameters("TABLE" )->asTable(); iField = Parameters("ID_FIELD")->asInt(); pGrids->Del_Items(); if( !pClasses->Set_Index() ) { Error_Set(_TL("index creation failed")); return( false ); } //----------------------------------------------------- if( pTable->Get_Field_Count() == 0 || pTable->Get_Count() == 0 ) { Message_Add(_TL("selected table contains no valid records")); return( false ); } //----------------------------------------------------- if( !pTable->Set_Index(iField, TABLE_INDEX_Ascending) ) { Message_Add(_TL("failed to create index for table")); return( false ); } //----------------------------------------------------- Attribute = new int[pTable->Get_Field_Count()]; for(iAttribute=0, nAttributes=0; iAttribute<pTable->Get_Field_Count(); iAttribute++) { if( iAttribute != iField && pTable->Get_Field_Type(iAttribute) != SG_DATATYPE_String ) { Attribute[nAttributes++] = iAttribute; CSG_Grid *pGrid = SG_Create_Grid(*Get_System()); pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pClasses->Get_Name(), pTable->Get_Field_Name(iAttribute))); pGrids->Add_Item(pGrid); } } if( nAttributes == 0 ) { delete[](Attribute); Message_Add(_TL("selected table does not have numeric attributes")); return( false ); } //----------------------------------------------------- CSG_Table_Record *pRecord = pTable->Get_Record_byIndex(0); for(iCell=0, iRecord=0; iCell<Get_NCells() && pRecord && Set_Progress_NCells(iCell); iCell++) { if( pClasses->Get_Sorted(iCell, jCell, false, true) ) { double valClass = pClasses->asDouble(jCell); while( pRecord && pRecord->asDouble(iField) < valClass ) { pRecord = pTable->Get_Record_byIndex(++iRecord); } if( !pRecord || pRecord->asDouble(iField) > valClass ) { for(iAttribute=0; iAttribute<nAttributes; iAttribute++) { pGrids->asGrid(iAttribute)->Set_NoData(jCell); } } else { for(iAttribute=0; iAttribute<nAttributes; iAttribute++) { pGrids->asGrid(iAttribute)->Set_Value(jCell, pRecord->asDouble(Attribute[iAttribute])); } } } } //----------------------------------------------------- delete[](Attribute); return true; }
//--------------------------------------------------------- bool CCropToData::On_Execute(void) { CSG_Parameter_Grid_List *pGrids = Parameters("INPUT")->asGridList(); //----------------------------------------------------- if( pGrids->Get_Count() <= 0 ) { Error_Set(_TL("no grids in selection")); return( false ); } //----------------------------------------------------- bool bCrop = false; int xMin, yMin, xMax, yMax; //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0; x<Get_NX(); x++) { bool bData = false; for(int i=0; i<pGrids->Get_Count() && !bData; i++) { if( !pGrids->asGrid(i)->is_NoData(x, y) ) { bData = true; } } if( bData ) { if( bCrop == false ) { bCrop = true; xMin = xMax = x; yMin = yMax = y; } else { if( xMin > x ) { xMin = x; } else if( xMax < x ) { xMax = x; } if( yMin > y ) { yMin = y; } else if( yMax < y ) { yMax = y; } } } } } //----------------------------------------------------- if( bCrop == false ) { Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("nothing to crop"), _TL("no valid data found in grid(s)"))); } else if( (1 + xMax - xMin) == Get_NX() && (1 + yMax - yMin) == Get_NY() ) { Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("nothing to crop"), _TL("valid data cells match original grid extent"))); } else { CSG_Parameter_Grid_List *pCropped = Parameters("OUTPUT")->asGridList(); pCropped->Del_Items(); for(int i=0; i<pGrids->Get_Count(); i++) { CSG_Grid *pGrid = SG_Create_Grid( pGrids->asGrid(i)->Get_Type(), 1 + xMax - xMin, 1 + yMax - yMin, Get_Cellsize(), Get_XMin() + xMin * Get_Cellsize(), Get_YMin() + yMin * Get_Cellsize() ); pGrid->Assign(pGrids->asGrid(i), GRID_INTERPOLATION_NearestNeighbour); pGrid->Set_Name(pGrids->asGrid(i)->Get_Name()); pCropped->Add_Item(pGrid); } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGrid_CVA::On_Execute(void) { //----------------------------------------------------- CSG_Parameter_Grid_List *pA = Parameters("A")->asGridList(); CSG_Parameter_Grid_List *pB = Parameters("B")->asGridList(); CSG_Parameter_Grid_List *pC = Parameters("C")->asGridList(); if( pA->Get_Grid_Count() != pB->Get_Grid_Count() ) { Error_Set(_TL("number of initial and final state grids differs")); return( false ); } if( pA->Get_Grid_Count() == 0 ) { Error_Set(_TL("no grids in list")); return( false ); } //----------------------------------------------------- int n = pA->Get_Grid_Count(); bool bAngle = Parameters("ANGLE")->asBool() && n == 2; bool bC_Out = Parameters("C_OUT")->asBool(); CSG_Grid *pDist = Parameters("DIST")->asGrid(); CSG_Grid *pDir = Parameters("DIR" )->asGrid(); //----------------------------------------------------- pC->Del_Items(); if( bC_Out ) { for(int i=0; i<n; i++) { CSG_Grid *pGrid = SG_Create_Grid(Get_System()); pGrid->Fmt_Name("%s %01d", _TL("Change Vector"), i + 1); pC->Add_Item(pGrid); } } //----------------------------------------------------- CSG_Parameter *pLUT; CSG_Colors Colors; Colors.Set_Count(100); Colors.Set_Ramp(SG_GET_RGB(255, 255, 255), SG_GET_RGB( 0, 127, 127), 0, Colors.Get_Count() / 2); Colors.Set_Ramp(SG_GET_RGB( 0, 127, 127), SG_GET_RGB(255, 0, 0), Colors.Get_Count() / 2, Colors.Get_Count()); DataObject_Set_Colors(pDist, Colors); if( (pLUT = DataObject_Get_Parameter(pDir, "LUT")) == NULL || pLUT->asTable() == NULL || bAngle ) { Colors.Set_Default(100); Colors.Set_Ramp_Brighness(255, 0, 0, Colors.Get_Count() / 2); Colors.Set_Ramp_Brighness( 0, 255, Colors.Get_Count() / 2, Colors.Get_Count()); DataObject_Set_Colors(pDir, Colors); DataObject_Set_Parameter(pDir, "COLORS_TYPE", 2); } else { pLUT->asTable()->Del_Records(); for(int i=0, nClasses=(int)pow(2.0, n); i<nClasses; i++) { CSG_String s; for(int j=0; j<n; j++) { s += i & (int)pow(2.0, j) ? '+' : '-'; } CSG_Table_Record *pClass = pLUT->asTable()->Add_Record(); pClass->Set_Value(1, s); pClass->Set_Value(3, i); pClass->Set_Value(4, i); } Colors.Set_Count(pLUT->asTable()->Get_Count()); Colors.Random(); for(int c=0; c<pLUT->asTable()->Get_Count(); c++) { pLUT->asTable()->Get_Record(c)->Set_Value(0, Colors.Get_Color(c)); } DataObject_Set_Parameter(pDir, pLUT); DataObject_Set_Parameter(pDir, "COLORS_TYPE", 1); // Color Classification Type: Lookup Table } //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #pragma omp parallel for for(int x=0; x<Get_NX(); x++) { bool bOkay; int i, j; double d; CSG_Vector v(n); for(i=0, bOkay=true; i<n && bOkay; i++) { if( pA->Get_Grid(i)->is_NoData(x, y) || pB->Get_Grid(i)->is_NoData(x, y) ) { bOkay = false; } else { v[i] = pB->Get_Grid(i)->asDouble(x, y) - pA->Get_Grid(i)->asDouble(x, y); } } //--------------------------------------------- if( bOkay ) { if( bAngle ) { d = atan2(v[0], v[1]); } else for(i=0, j=1, d=0.0; i<n; i++, j*=2) { if( v[i] >= 0.0 ) { d += j; } } pDist->Set_Value(x, y, v.Get_Length()); pDir ->Set_Value(x, y, d); for(i=0; i<n && bC_Out; i++) { pC->Get_Grid(i)->Set_Value(x, y, v[i]); } } //--------------------------------------------- else { pDist->Set_NoData(x, y); pDir ->Set_NoData(x, y); for(i=0; i<n && bC_Out; i++) { pC->Get_Grid(i)->Set_NoData(x, y); } } } } return( true ); }
//--------------------------------------------------------- bool CPROJ4_Grid::On_Execute_Conversion(void) { TSG_Data_Type Type; TSG_Rect Extent; CSG_Grid *pSource, *pGrid; CSG_Shapes *pShapes; m_Interpolation = Parameters("INTERPOLATION")->asInt(); //----------------------------------------------------- if( m_bInputList ) { CSG_Parameter_Grid_List *pSources = Parameters("SOURCE")->asGridList(); CSG_Parameter_Grid_List *pTargets = Parameters("TARGET")->asGridList(); if( pSources->Get_Count() < 1 ) { return( false ); } pSource = pSources->asGrid(0); pGrid = NULL; pShapes = NULL; Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float; switch( Parameters("TARGET_TYPE")->asInt() ) { case 0: // create new user defined grid... if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") ) { pGrid = m_Grid_Target.Get_User(Type); } break; case 1: // select grid system... if( Dlg_Parameters("<") && Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System()->is_Valid() ) { pGrid = SG_Create_Grid(*Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), Type); } break; case 2: // shapes... if( Dlg_Parameters("GET_SHAPES") ) { pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes(); if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE ) { Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes()); } } break; } //------------------------------------------------- if( pShapes ) { Parameters("SHAPES")->Set_Value(pShapes); return( Set_Shapes(pSources, pShapes) ); } if( pGrid ) { pTargets->Del_Items(); pTargets->Add_Item(pGrid); Init_Target(pSource, pGrid); for(int i=1; i<pSources->Get_Count(); i++) { pTargets->Add_Item(SG_Create_Grid(pGrid->Get_System(), m_Interpolation == 0 ? pSources->asGrid(i)->Get_Type() : SG_DATATYPE_Float)); Init_Target(pSources->asGrid(i), pTargets->asGrid(i)); } return( Set_Grids(pSources, pTargets) ); } } //----------------------------------------------------- else { pSource = Parameters("SOURCE")->asGrid(); pGrid = NULL; pShapes = NULL; Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float; switch( Parameters("TARGET_TYPE")->asInt() ) { case 0: // create new user defined grid... if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") ) { pGrid = m_Grid_Target.Get_User(Type); } break; case 1: // select grid... if( Dlg_Parameters("GET_GRID") ) { pGrid = m_Grid_Target.Get_Grid(Type); } break; case 2: // shapes... if( Dlg_Parameters("GET_SHAPES") ) { pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes(); if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE ) { Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes()); } } break; } //------------------------------------------------- if( pShapes ) { Parameters("SHAPES")->Set_Value(pShapes); return( Set_Shapes(pSource, pShapes) ); } if( pGrid ) { return( Set_Grid(pSource, pGrid) ); } } //----------------------------------------------------- return( false ); }
//--------------------------------------------------------- bool CGrid_Tiling::On_Execute(void) { bool bSaveTiles; int ix, iy, nx, ny, Overlap; double y, x, dx, dy, dCell; CSG_String FilePath, BaseName; TSG_Data_Type Type; TSG_Rect Extent; TSG_Grid_Resampling Interpolation; CSG_Grid *pGrid, *pTile; CSG_Parameter_Grid_List *pTiles; //----------------------------------------------------- pGrid = Parameters("GRID") ->asGrid(); pTiles = Parameters("TILES") ->asGridList(); Overlap = Parameters("OVERLAP") ->asInt(); bSaveTiles = Parameters("SAVE_TILES") ->asBool(); BaseName = Parameters("TILE_BASENAME") ->asString(); FilePath = Parameters("TILE_PATH") ->asString(); switch( Parameters("METHOD")->asInt() ) { case 0: default: Extent.xMin = pGrid->Get_XMin(); Extent.xMax = pGrid->Get_XMax(); Extent.yMin = pGrid->Get_YMin(); Extent.yMax = pGrid->Get_YMax(); dCell = pGrid->Get_Cellsize(); nx = Parameters("NX") ->asInt(); ny = Parameters("NY") ->asInt(); dx = dCell * nx; dy = dCell * ny; Type = pGrid->Get_Type(); Interpolation = GRID_RESAMPLING_NearestNeighbour; break; case 1: Extent.xMin = Parameters("XRANGE") ->asRange()->Get_LoVal(); Extent.xMax = Parameters("XRANGE") ->asRange()->Get_HiVal(); Extent.yMin = Parameters("YRANGE") ->asRange()->Get_LoVal(); Extent.yMax = Parameters("YRANGE") ->asRange()->Get_HiVal(); dCell = Parameters("DCELL") ->asDouble(); dx = Parameters("DX") ->asDouble(); dy = Parameters("DY") ->asDouble(); nx = (int)(dx / dCell); ny = (int)(dy / dCell); Type = pGrid->Get_Type(); Interpolation = GRID_RESAMPLING_Undefined; break; } switch( Parameters("OVERLAP_SYM")->asInt() ) { case 0: default: // symetric nx += Overlap * 2; ny += Overlap * 2; break; case 1: // bottom / left nx += Overlap; ny += Overlap; break; case 2: // top / right nx += Overlap; ny += Overlap; Overlap = 0; break; } pTiles->Del_Items(); //----------------------------------------------------- if( dx <= 0.0 || dy <= 0.0 || dCell <= 0.0 ) { Message_Add(_TL("no intersection with mask grid.")); return( false ); } if( bSaveTiles ) { if( !SG_STR_CMP(BaseName, SG_T("")) ) { SG_UI_Msg_Add_Error(_TL("Please provide a valid base name for the output files!")); return( false ); } if( !SG_STR_CMP(FilePath, SG_T("")) ) { SG_UI_Msg_Add_Error(_TL("Please provide a valid output directory for the output files!")); return( false ); } } //----------------------------------------------------- int iTiles = 0; for(y=Extent.yMin, iy=1; y<Extent.yMax && Process_Get_Okay(); y+=dy, iy++) { for(x=Extent.xMin, ix=1; x<Extent.xMax; x+=dx, ix++) { pTile = SG_Create_Grid(Type, nx, ny, dCell, x - dCell * Overlap, y - dCell * Overlap); pTile ->Assign(pGrid, Interpolation); pTile ->Set_Name(CSG_String::Format(SG_T("%s [%d, %d]"), pGrid->Get_Name(), iy, ix)); if( pTile->Get_NoData_Count() == pTile->Get_NCells() ) { delete(pTile); } else { if( bSaveTiles ) { CSG_String FileName = CSG_String::Format(SG_T("%s/%s_%d_%d"), FilePath.c_str(), BaseName.c_str(), iy, ix); pTile->Save(FileName); delete(pTile); } else { pTiles->Add_Item(pTile); } iTiles++; } } } SG_UI_Msg_Add(CSG_String::Format(_TL("%d tiles created."), iTiles), true); return( iTiles > 0 ); }
//--------------------------------------------------------- bool CGCS_Grid_Longitude_Range::On_Execute(void) { CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList(); CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList(); if( pInput->Get_Count() <= 0 ) { Message_Dlg(_TL("nothing to do: no data in selection")); return( false ); } pOutput->Del_Items(); //----------------------------------------------------- int xZero; CSG_Grid_System Target; //----------------------------------------------------- if( Parameters("DIRECTION")->asInt() == 0 ) // 0 - 360 >> -180 - 180 { if( Get_XMax() <= 180.0 ) { Message_Add(_TL("Nothing to do. Raster is already within target range.")); return( true ); } else if( Get_XMin() >= 180.0 ) { xZero = 0; Target.Assign(Get_Cellsize(), Get_XMin() - 360.0, Get_YMin(), Get_NX(), Get_NY()); } else if( Get_XMax() - 360.0 < Get_XMin() - Get_Cellsize() ) { Error_Set(_TL("Nothing to do be done. Raster splitting is not supported.")); return( false ); } else { xZero = (int)(0.5 + 180.0 / Get_Cellsize()); Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY()); } } //----------------------------------------------------- else // -180 - 180 >> 0 - 360 { if( Get_XMin() >= 0.0 ) { Message_Add(_TL("Nothing to do. Raster is already within target range.")); return( true ); } else if( Get_XMax() <= 0.0 ) { xZero = 0; Target.Assign(Get_Cellsize(), Get_XMin() + 360.0, Get_YMin(), Get_NX(), Get_NY()); } else if( Get_XMin() + 360.0 > Get_XMax() + Get_Cellsize() ) { Error_Set(_TL("Nothing to do be done. Raster splitting is not supported.")); return( false ); } else { xZero = (int)(0.5 + 180.0 / Get_Cellsize()); Target.Assign(Get_Cellsize(), Get_XMin() - 180.0, Get_YMin(), Get_NX(), Get_NY()); } } //----------------------------------------------------- for(int i=0; i<pInput->Get_Count() && Process_Get_Okay(); i++) { CSG_Grid *pIn = pInput->asGrid(i); CSG_Grid *pOut = SG_Create_Grid(Target, pIn->Get_Type()); pOut->Set_Name(pIn->Get_Name()); pOut->Set_NoData_Value_Range(pIn->Get_NoData_Value(), pIn->Get_NoData_hiValue()); pOut->Set_ZFactor(pIn->Get_ZFactor()); pOutput->Add_Item(pOut); for(int y=0; y<Get_NY() && Set_Progress(y); y++) { for(int x=0, xx=xZero; x<Get_NX(); x++, xx++) { if( xx >= Get_NX() ) { xx = 0; } pOut->Set_Value(xx, y, pIn->asDouble(x, y)); } } } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGW_Multi_Regression_Grid::On_Execute(void) { int i; //----------------------------------------------------- CSG_Parameter_Grid_List *pPredictors = Parameters("PREDICTORS")->asGridList(); if( !Initialize(Parameters("POINTS")->asShapes(), Parameters("DEPENDENT")->asInt(), pPredictors) ) { Finalize(); return( false ); } //----------------------------------------------------- CSG_Grid Quality; m_dimModel = *Get_System(); if( Parameters("RESOLUTION")->asInt() == 1 && Parameters("RESOLUTION_VAL")->asDouble() > Get_Cellsize() ) { CSG_Rect r(Get_System()->Get_Extent()); r.Inflate(0.5 * Parameters("RESOLUTION_VAL")->asDouble(), false); m_dimModel.Assign(Parameters("RESOLUTION_VAL")->asDouble(), r); Quality.Create(m_dimModel); m_pQuality = &Quality; } else { m_pQuality = Parameters("QUALITY")->asGrid(); } //----------------------------------------------------- Process_Set_Text(_TL("upsetting model domain")); m_pPredictors = (CSG_Grid **)SG_Calloc(m_nPredictors , sizeof(CSG_Grid *)); m_pModel = (CSG_Grid **)SG_Calloc(m_nPredictors + 1, sizeof(CSG_Grid *)); for(i=0; i<m_nPredictors; i++) { if( m_dimModel.Get_Cellsize() > Get_Cellsize() ) // scaling { m_pPredictors[i] = SG_Create_Grid(m_dimModel); m_pPredictors[i] ->Assign(pPredictors->asGrid(i), GRID_INTERPOLATION_NearestNeighbour); // GRID_INTERPOLATION_Mean_Cells } else { m_pPredictors[i] = pPredictors->asGrid(i); } m_pModel [i] = SG_Create_Grid(m_dimModel); m_pModel [i] ->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pPredictors->asGrid(i)->Get_Name(), _TL("Factor"))); } m_pModel[m_nPredictors] = SG_Create_Grid(m_dimModel); m_pModel[m_nPredictors] ->Set_Name(_TL("Intercept")); //----------------------------------------------------- Process_Set_Text(_TL("model creation")); bool bResult = Get_Model(); //----------------------------------------------------- if( m_dimModel.Get_Cellsize() > Get_Cellsize() ) // scaling { for(i=0; i<m_nPredictors; i++) { delete(m_pPredictors[i]); m_pPredictors[i] = pPredictors->asGrid(i); } } //----------------------------------------------------- if( bResult ) { Process_Set_Text(_TL("model application")); bResult = Set_Model(); } //----------------------------------------------------- if( Parameters("MODEL_OUT")->asBool() ) { CSG_Parameter_Grid_List *pModel = Parameters("MODEL")->asGridList(); pModel->Del_Items(); pModel->Add_Item(m_pModel[m_nPredictors]); for(i=0; i<m_nPredictors; i++) { pModel->Add_Item(m_pModel[i]); } } else { for(i=0; i<=m_nPredictors; i++) { delete(m_pModel[i]); } } SG_FREE_SAFE(m_pModel); SG_FREE_SAFE(m_pPredictors); Finalize(); return( bResult ); }
//--------------------------------------------------------- bool CGWR_Grid_Downscaling::On_Execute(void) { //----------------------------------------------------- CSG_Parameter_Grid_List *pPredictors = Parameters("PREDICTORS")->asGridList(); if( (m_nPredictors = pPredictors->Get_Count()) <= 0 ) { return( false ); } m_pDependent = Parameters("DEPENDENT")->asGrid(); if( !m_pDependent->Get_Extent().Intersects(Get_System()->Get_Extent()) ) { return( false ); } //----------------------------------------------------- int i; Process_Set_Text(_TL("upscaling of predictors")); m_pPredictors = (CSG_Grid **)SG_Calloc(m_nPredictors , sizeof(CSG_Grid *)); m_pModel = (CSG_Grid **)SG_Calloc(m_nPredictors + 1, sizeof(CSG_Grid *)); for(i=0; i<m_nPredictors; i++) { m_pPredictors[i] = SG_Create_Grid(m_pDependent->Get_System()); m_pPredictors[i] ->Assign(pPredictors->asGrid(i), GRID_INTERPOLATION_NearestNeighbour); // GRID_INTERPOLATION_Mean_Cells m_pModel [i] = SG_Create_Grid(m_pDependent->Get_System()); m_pModel [i] ->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pPredictors->asGrid(i)->Get_Name(), _TL("Factor"))); } m_pModel[m_nPredictors] = SG_Create_Grid(m_pDependent->Get_System()); m_pModel[m_nPredictors] ->Set_Name(_TL("Intercept")); //----------------------------------------------------- Process_Set_Text(_TL("model creation")); bool bResult = Get_Model(); //----------------------------------------------------- for(i=0; i<m_nPredictors; i++) { delete(m_pPredictors[i]); m_pPredictors[i] = pPredictors->asGrid(i); } //----------------------------------------------------- if( bResult ) { Process_Set_Text(_TL("downscaling")); bResult = Set_Model(); } //----------------------------------------------------- if( Parameters("MODEL_OUT")->asBool() ) { CSG_Parameter_Grid_List *pModel = Parameters("MODEL")->asGridList(); pModel->Del_Items(); pModel->Add_Item(m_pModel[m_nPredictors]); for(i=0; i<m_nPredictors; i++) { pModel->Add_Item(m_pModel[i]); } } else { for(i=0; i<=m_nPredictors; i++) { delete(m_pModel[i]); } } SG_FREE_SAFE(m_pModel); SG_FREE_SAFE(m_pPredictors); return( bResult ); }