//---------------------------------------------------------
bool CFilter_Resample::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("GRID" )->asGrid();
CSG_Grid *pLoPass = Parameters("LOPASS")->asGrid();
CSG_Grid *pHiPass = Parameters("HIPASS")->asGrid();
double Cellsize = Parameters("SCALE" )->asDouble() * Get_Cellsize();
//-----------------------------------------------------
if( Cellsize > 0.5 * SG_Get_Length(Get_System().Get_XRange(), Get_System().Get_YRange()) )
{
Error_Set(_TL("resampling cell size is too large"));
return( false );
}
//-----------------------------------------------------
CSG_Grid Grid(CSG_Grid_System(Cellsize, Get_XMin(), Get_YMin(), Get_XMax(), Get_YMax()), SG_DATATYPE_Float);
Grid.Assign(pGrid, GRID_RESAMPLING_Mean_Cells);
//-----------------------------------------------------
pLoPass->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("Low Pass" ));
pHiPass->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("High Pass"));
CSG_Colors Colors;
DataObject_Get_Colors(pGrid , Colors);
DataObject_Set_Colors(pLoPass, Colors);
DataObject_Set_Colors(pHiPass, 11, SG_COLORS_RED_GREY_BLUE);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
double py = Get_YMin() + y * Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double z, px = Get_XMin() + x * Get_Cellsize();
if( !pGrid->is_NoData(x, y) && Grid.Get_Value(px, py, z) )
{
pLoPass->Set_Value(x, y, z);
pHiPass->Set_Value(x, y, pGrid->asDouble(x, y) - z);
}
else
{
pLoPass->Set_NoData(x, y);
pHiPass->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPanSharp_Brovey::On_Execute(void)
{
//-----------------------------------------------------
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
//-----------------------------------------------------
CSG_Grid *pPan = Parameters("PAN")->asGrid();
//-----------------------------------------------------
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("R")->asGrid()->Get_Name());
CSG_Grid *pR = Parameters("R_SHARP")->asGrid();
pR->Assign (Parameters("R")->asGrid(), Resampling);
pR->Set_Name(Parameters("R")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("G")->asGrid()->Get_Name());
CSG_Grid *pG = Parameters("G_SHARP")->asGrid();
pG->Assign (Parameters("G")->asGrid(), Resampling);
pG->Set_Name(Parameters("G")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("B")->asGrid()->Get_Name());
CSG_Grid *pB = Parameters("B_SHARP")->asGrid();
pB->Assign (Parameters("B")->asGrid(), Resampling);
pB->Set_Name(Parameters("B")->asGrid()->Get_Name());
//-----------------------------------------------------
Process_Set_Text(_TL("Sharpening"));
for(int y=0; y<pPan->Get_NY() && Set_Progress(y, pPan->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pPan->Get_NX(); x++)
{
if( !pPan->is_NoData(x, y) && !pR->is_NoData(x, y) && !pG->is_NoData(x, y) && !pB->is_NoData(x, y) )
{
double k = (pR->asDouble(x, y) + pG->asDouble(x, y) + pB->asDouble(x, y));
if( k != 0.0 )
{
k = pPan->asDouble(x, y) / k;
}
pR->Mul_Value(x, y, k);
pG->Mul_Value(x, y, k);
pB->Mul_Value(x, y, k);
}
else
{
pR->Set_NoData(x, y);
pG->Set_NoData(x, y);
pB->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Division::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pA = Parameters("A")->asGrid();
CSG_Grid *pB = Parameters("B")->asGrid();
CSG_Grid *pC = Parameters("C")->asGrid();
DataObject_Set_Colors(pC, 11, SG_COLORS_RED_GREY_BLUE);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pA->is_NoData(x, y) || pB->is_NoData(x, y) || pB->asDouble(x, y) == 0.0 )
{
pC->Set_NoData(x, y);
}
else
{
pC->Set_Value(x, y, pA->asDouble(x, y) / pB->asDouble(x, y));
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
void CHillslope_Evolution_FTCS::Set_Difference(void)
{
CSG_Grid *pDiff = Parameters("DIFF")->asGrid();
if( pDiff )
{
CSG_Grid *pDEM = Parameters("DEM")->asGrid();
#pragma omp parallel for
for(int i=0; i<Get_NCells(); i++)
{
if( pDEM->is_NoData(i) )
{
pDiff->Set_NoData(i);
}
else
{
pDiff->Set_Value(i, m_pDEM->asDouble(i) - pDEM->asDouble(i));
}
}
if( Parameters("UPDATE")->asBool() )
{
DataObject_Update(pDiff, SG_UI_DATAOBJECT_SHOW);
}
}
}
//---------------------------------------------------------
bool CConvergence::On_Execute(void)
{
bool bGradient;
int Neighbours;
CSG_Grid *pConvergence;
m_pDTM = Parameters("ELEVATION") ->asGrid();
pConvergence = Parameters("RESULT") ->asGrid();
Neighbours = Parameters("NEIGHBOURS") ->asInt();
bGradient = Parameters("METHOD") ->asInt() == 1;
DataObject_Set_Colors(pConvergence, 100, SG_COLORS_RED_GREY_BLUE, true);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( m_pDTM->is_InGrid(x, y) )
{
switch( Neighbours )
{
case 0: default: pConvergence->Set_Value(x, y, Get_2x2(x, y, bGradient)); break;
case 1: pConvergence->Set_Value(x, y, Get_9x9(x, y, bGradient)); break;
}
}
else
{
pConvergence->Set_NoData(x, y);
}
}
}
return( true );
}
//---------------------------------------------------------
bool CFilter_Rank::On_Execute(void)
{
int x, y;
double Rank;
CSG_Grid *pResult;
//-----------------------------------------------------
m_pInput = Parameters("INPUT" )->asGrid();
pResult = Parameters("RESULT")->asGrid();
Rank = Parameters("RANK" )->asInt() / 100.0;
//-----------------------------------------------------
m_Kernel.Set_Radius(Parameters("RADIUS")->asInt(), Parameters("MODE")->asInt() == 0);
//-----------------------------------------------------
if( !pResult || pResult == m_pInput )
{
pResult = SG_Create_Grid(m_pInput);
}
else
{
pResult->Set_Name(CSG_String::Format(SG_T("%s [%s: %.1f]"), m_pInput->Get_Name(), _TL("Rank"), 100.0 * Rank));
pResult->Set_NoData_Value(m_pInput->Get_NoData_Value());
}
//-----------------------------------------------------
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel private(x)
for(x=0; x<Get_NX(); x++)
{
double Value;
if( Get_Value(x, y, Rank, Value) )
{
pResult->Set_Value(x, y, Value);
}
else
{
pResult->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
if( !Parameters("RESULT")->asGrid() || Parameters("RESULT")->asGrid() == m_pInput )
{
m_pInput->Assign(pResult);
delete(pResult);
DataObject_Update(m_pInput);
}
m_Kernel.Destroy();
return( true );
}
//---------------------------------------------------------
bool CFilter_LoG::On_Execute(void)
{
CSG_Grid *pResult;
//-----------------------------------------------------
m_pInput = Parameters("INPUT") ->asGrid();
pResult = Parameters("RESULT") ->asGrid();
//-----------------------------------------------------
if( Initialise() )
{
if( !pResult || pResult == m_pInput )
{
pResult = SG_Create_Grid(m_pInput);
}
else
{
pResult->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pInput->Get_Name(), _TL("Laplace Filter")));
pResult->Set_NoData_Value(m_pInput->Get_NoData_Value());
}
//-------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( m_pInput->is_InGrid(x, y) )
{
pResult->Set_Value(x, y, Get_Value(x, y));
}
else
{
pResult->Set_NoData(x, y);
}
}
}
//-------------------------------------------------
if( !Parameters("RESULT")->asGrid() || Parameters("RESULT")->asGrid() == m_pInput )
{
m_pInput->Assign(pResult);
delete(pResult);
pResult = m_pInput;
}
DataObject_Set_Colors(pResult, 100, SG_COLORS_BLACK_WHITE);
m_Kernel.Destroy();
return( true );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CGrids_Product::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS" )->asGridList();
if( pGrids->Get_Count() < 1 )
{
Error_Set(_TL("no grid in list"));
return( false );
}
//-----------------------------------------------------
CSG_Grid *pResult = Parameters("RESULT")->asGrid();
bool bNoData = Parameters("NODATA")->asBool();
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
int n = 0;
double d = 0.0;
for(int i=0; i<pGrids->Get_Count(); i++)
{
if( pGrids->asGrid(i)->is_InGrid(x, y) )
{
if( n++ < 1 )
{
d = pGrids->asGrid(i)->asDouble(x, y);
}
else
{
d *= pGrids->asGrid(i)->asDouble(x, y);
}
}
}
if( bNoData ? n > 0 : n == pGrids->Get_Count() )
{
pResult->Set_Value(x, y, d);
}
else
{
pResult->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_RGB_Split::On_Execute(void)
{
CSG_Grid *pRGB = Parameters("RGB")->asGrid();
if( SG_Data_Type_Get_Size(pRGB->Get_Type()) < 4 )
{
Message_Add(_TL("warning, input uses less than 4 bytes per value"));
}
bool bNoData = Parameters("NODATA")->asBool();
CSG_Grid *pR = Parameters("R")->asGrid(); if( bNoData && pR ) pR->Set_NoData_Value(-1);
CSG_Grid *pG = Parameters("G")->asGrid(); if( bNoData && pG ) pG->Set_NoData_Value(-1);
CSG_Grid *pB = Parameters("B")->asGrid(); if( bNoData && pB ) pB->Set_NoData_Value(-1);
CSG_Grid *pA = Parameters("A")->asGrid(); if( bNoData && pA ) pA->Set_NoData_Value(-1);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( bNoData || !pRGB->is_NoData(x, y) )
{
int RGB = pRGB->asInt(x, y);
if( pR ) pR->Set_Value(x, y, SG_GET_R(RGB));
if( pG ) pG->Set_Value(x, y, SG_GET_G(RGB));
if( pB ) pB->Set_Value(x, y, SG_GET_B(RGB));
if( pA ) pA->Set_Value(x, y, SG_GET_A(RGB));
}
else
{
if( pR ) pR->Set_NoData(x, y);
if( pG ) pG->Set_NoData(x, y);
if( pB ) pB->Set_NoData(x, y);
if( pA ) pA->Set_NoData(x, y);
}
}
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Mask::On_Execute(void)
{
CSG_Grid *pGrid = Parameters("GRID")->asGrid();
CSG_Grid *pMask = Parameters("MASK")->asGrid();
if( !pGrid->is_Intersecting(pMask->Get_Extent()) )
{
Message_Add(_TL("no intersection with mask grid."));
return( false );
}
//-----------------------------------------------------
CSG_Grid *pMasked = Parameters("MASKED")->asGrid();
if( pMasked && pMasked != pGrid )
{
pMasked->Create(*pGrid);
pMasked->Fmt_Name("%s [%s]", pGrid->Get_Name(), _TL("masked"));
pGrid = pMasked;
}
//-----------------------------------------------------
Process_Set_Text(_TL("masking..."));
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
double py = Get_YMin() + y * Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
double px = Get_XMin() + x * Get_Cellsize();
if( !pMask->is_InGrid_byPos(px, py) )
{
pGrid->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGWR_Grid_Downscaling::Set_Model(void)
{
CSG_Grid *pRegression = Parameters("REGRESSION" )->asGrid();
CSG_Grid *pReg_ResCorr = Parameters("REG_RESCORR")->asGrid();
pRegression->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pDependent->Get_Name(), _TL("GWR")));
if( pReg_ResCorr )
{
pReg_ResCorr->Set_Name(CSG_String::Format(SG_T("%s [%s, %s]"), m_pDependent->Get_Name(), _TL("GWR"), _TL("Residual Correction")));
}
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
double p_y = Get_YMin() + y * Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double Value, Residual, p_x = Get_XMin() + x * Get_Cellsize();
if( Set_Model(p_x, p_y, Value, Residual) )
{
pRegression->Set_Value(x, y, Value);
if( pReg_ResCorr )
{
pReg_ResCorr->Set_Value(x, y, Value + Residual);
}
}
else
{
pRegression->Set_NoData(x, y);
if( pReg_ResCorr )
{
pReg_ResCorr->Set_NoData(x, y);
}
}
}
}
return( true );
}
bool CCombineGrids::On_Execute(void){
int x,y;
int i;
int iCellValue1, iCellValue2;
int iTableValue1, iTableValue2;
int iResultValue;
CSG_Grid *pGrid1 = Parameters("GRID1")->asGrid();
CSG_Grid *pGrid2 = Parameters("GRID2")->asGrid();
CSG_Grid *pResult = Parameters("RESULT")->asGrid(); ;
CSG_Table *pLookup;
CSG_Table_Record *pRecord;
pLookup = Parameters("LOOKUP")->asTable();
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
iCellValue1 = pGrid1->asInt(x,y);
iCellValue2 = pGrid2->asInt(x,y);
for (i = 0; i < pLookup->Get_Record_Count(); i++){
pRecord = pLookup->Get_Record(i);
iTableValue1 = pRecord->asInt(0);
iTableValue2 = pRecord->asInt(1);
if (iTableValue1 == iCellValue1){
if (iTableValue2 == iCellValue2){
iResultValue = pRecord->asInt(2);
pResult->Set_Value(x,y,iResultValue);
break;
}//if
}//if
}//for
if (i >= pLookup->Get_Record_Count()){
pResult->Set_NoData(x,y);
}//if
}//for
}//for
return true;
}//method
//---------------------------------------------------------
bool CGrid_Histogram_Surface::Get_Circle(void)
{
long i;
int n;
double r;
CSG_Grid *pHist;
r = sqrt(m_pGrid->Get_NCells() / M_PI);
n = 1 + (int)(2.0 * r);
//-----------------------------------------------------
Parameters("HIST")->Set_Value(pHist = SG_Create_Grid(m_pGrid->Get_Type(), n, n, m_pGrid->Get_Cellsize(), -r * m_pGrid->Get_Cellsize(), -r * m_pGrid->Get_Cellsize()));
pHist->Set_NoData_Value_Range(
m_pGrid->Get_NoData_Value(),
m_pGrid->Get_NoData_hiValue()
);
//-----------------------------------------------------
for(int y=0; y<n && Set_Progress(y, n); y++)
{
for(int x=0; x<n; x++)
{
double d = SG_Get_Distance(x, y, r, r);
if( d < r && m_pGrid->Get_Sorted((long)(d*d*M_PI), i) )
{
pHist->Set_Value(x, y, m_pGrid->asDouble(i));
}
else
{
pHist->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
return( true );
}
bool CRealArea::On_Execute(void)
{
CSG_Grid *pDEM = Parameters("DEM" )->asGrid();
CSG_Grid *pArea = Parameters("AREA")->asGrid();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
double s, a;
if( pDEM->Get_Gradient(x, y, s, a) )
{
pArea->Set_Value(x, y, Get_System()->Get_Cellarea() / cos(s));
}
else
{
pArea->Set_NoData(x,y);
}
}
}
return( true );
}
bool CProtectionIndex::On_Execute(void){
int x,y;
double dProtectionIndex;
CSG_Grid* pProtectionIndex = Parameters("PROTECTION")->asGrid();
m_dRadius = Parameters("RADIUS")->asDouble();
m_pDEM = Parameters("DEM")->asGrid();
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
dProtectionIndex = getProtectionIndex(x,y);
if (dProtectionIndex == NO_DATA){
pProtectionIndex->Set_NoData(x,y);
}//if
else{
pProtectionIndex->Set_Value(x,y, dProtectionIndex);
}//else
}//for
}//for
return true;
}//method
//---------------------------------------------------------
bool CPanSharp_IHS::On_Execute(void)
{
//-----------------------------------------------------
TSG_Grid_Resampling Resampling = Get_Resampling(Parameters("RESAMPLING")->asInt());
//-----------------------------------------------------
int y;
CSG_Grid *pPan = Parameters("PAN")->asGrid();
//-----------------------------------------------------
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("R")->asGrid()->Get_Name());
CSG_Grid *pR = Parameters("R_SHARP")->asGrid();
pR->Assign (Parameters("R")->asGrid(), Resampling);
pR->Set_Name(Parameters("R")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("G")->asGrid()->Get_Name());
CSG_Grid *pG = Parameters("G_SHARP")->asGrid();
pG->Assign (Parameters("G")->asGrid(), Resampling);
pG->Set_Name(Parameters("G")->asGrid()->Get_Name());
Process_Set_Text("%s: %s ...", _TL("Resampling"), Parameters("B")->asGrid()->Get_Name());
CSG_Grid *pB = Parameters("B_SHARP")->asGrid();
pB->Assign (Parameters("B")->asGrid(), Resampling);
pB->Set_Name(Parameters("B")->asGrid()->Get_Name());
//-----------------------------------------------------
Process_Set_Text(_TL("RGB to IHS"));
double rMin = pR->Get_Min(), rRange = pR->Get_Range();
double gMin = pG->Get_Min(), gRange = pG->Get_Range();
double bMin = pB->Get_Min(), bRange = pB->Get_Range();
for(y=0; y<pPan->Get_NY() && Set_Progress(y, pPan->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pPan->Get_NX(); x++)
{
bool bNoData = true;
if( pPan->is_NoData(x, y) || pR->is_NoData(x, y) || pG->is_NoData(x, y) || pB->is_NoData(x, y) )
{
pR->Set_NoData(x, y);
pG->Set_NoData(x, y);
pB->Set_NoData(x, y);
}
else
{
double r = (pR->asDouble(x, y) - rMin) / rRange; if( r < 0.0 ) r = 0.0; else if( r > 1.0 ) r = 1.0;
double g = (pG->asDouble(x, y) - gMin) / gRange; if( g < 0.0 ) g = 0.0; else if( g > 1.0 ) g = 1.0;
double b = (pB->asDouble(x, y) - bMin) / bRange; if( b < 0.0 ) b = 0.0; else if( b > 1.0 ) b = 1.0;
double h, s, i = r + g + b;
if( i <= 0.0 )
{
h = 0.0;
s = 0.0;
}
else
{
if( r == g && g == b ) { h = 0.0; }
else if( b < r && b < g ) { h = (g - b) / (i - 3 * b) ; }
else if( r < g && r < b ) { h = (b - r) / (i - 3 * r) + 1; }
else { h = (r - g) / (i - 3 * g) + 2; }
if ( 0.0 <= h && h < 1.0 ) { s = (i - 3 * b) / i; }
else if( 1.0 <= h && h < 2.0 ) { s = (i - 3 * r) / i; }
else { s = (i - 3 * g) / i; }
}
pR->Set_Value(x, y, i);
pG->Set_Value(x, y, s);
pB->Set_Value(x, y, h);
}
}
}
//-----------------------------------------------------
double Offset_Pan, Offset, Scale;
if( Parameters("PAN_MATCH")->asInt() == 0 )
{
Offset_Pan = pPan->Get_Min();
Offset = pR->Get_Min();
Scale = pR->Get_Range() / pPan->Get_Range();
}
else
{
Offset_Pan = pPan->Get_Mean();
Offset = pR->Get_Mean();
Scale = pR->Get_StdDev() / pPan->Get_StdDev();
}
//-----------------------------------------------------
Process_Set_Text(_TL("IHS to RGB"));
for(y=0; y<pPan->Get_NY() && Set_Progress(y, pPan->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pPan->Get_NX(); x++)
{
if( !pR->is_NoData(x, y) )
{
double i = Offset + Scale * (pPan->asDouble(x, y) - Offset_Pan);
double s = pG ->asDouble(x, y);
double h = pB ->asDouble(x, y);
double r, g, b;
if ( 0.0 <= h && h < 1.0 )
{
r = i * (1 + 2 * s - 3 * s * h) / 3;
g = i * (1 - s + 3 * s * h) / 3;
b = i * (1 - s ) / 3;
}
else if( 1.0 <= h && h < 2.0 )
{
r = i * (1 - s ) / 3;
g = i * (1 + 2 * s - 3 * s * (h - 1)) / 3;
b = i * (1 - s + 3 * s * (h - 1)) / 3;
}
else
{
r = i * (1 - s + 3 * s * (h - 2)) / 3;
g = i * (1 - s ) / 3;
b = i * (1 + 2 * s - 3 * s * (h - 2)) / 3;
}
pR->Set_Value(x, y, rMin + r * rRange);
pG->Set_Value(x, y, gMin + g * gRange);
pB->Set_Value(x, y, bMin + b * bRange);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CFuzzyOR::On_Execute(void)
{
int Type;
CSG_Grid *pOR;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pGrids = Parameters("GRIDS") ->asGridList();
pOR = Parameters("OR") ->asGrid();
Type = Parameters("TYPE") ->asInt();
//-----------------------------------------------------
if( pGrids->Get_Count() < 1 )
{
return( false );
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bNoData = pGrids->asGrid(0)->is_NoData(x, y);
double OR = pGrids->asGrid(0)->asDouble (x, y);
for(int i=1; i<pGrids->Get_Count() && !bNoData; i++)
{
if( !(bNoData = pGrids->asGrid(i)->is_NoData(x, y)) )
{
double iz = pGrids->asGrid(i)->asDouble(x, y);
switch( Type )
{
case 0:
if( OR < iz )
{
OR = iz;
}
break;
case 1:
OR = OR + iz - OR * iz;
break;
case 2:
if( (OR = OR + iz) > 1.0 )
{
OR = 1.0;
}
break;
}
}
}
if( bNoData )
{
pOR->Set_NoData(x, y);
}
else
{
pOR->Set_Value(x, y, OR);
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CAir_Flow_Height::On_Execute(void)
{
CSG_Grid *pAFH;
//-----------------------------------------------------
m_pDEM = Parameters("DEM" )->asGrid();
pAFH = Parameters("AFH" )->asGrid();
m_maxDistance = Parameters("MAXDIST")->asDouble() * 1000.0;
m_Acceleration = Parameters("ACCEL" )->asDouble();
m_dLee = Parameters("LEE" )->asDouble();
m_dLuv = Parameters("LUV" )->asDouble();
// m_bTrace = Parameters("TRACE" )->asBool();
//-----------------------------------------------------
CSG_Colors Colors(5);
Colors.Set_Color(0, 255, 127, 63);
Colors.Set_Color(1, 255, 255, 127);
Colors.Set_Color(2, 255, 255, 255);
Colors.Set_Color(3, 127, 127, 175);
Colors.Set_Color(4, 0, 0, 100);
DataObject_Set_Colors(pAFH, Colors);
//-----------------------------------------------------
bool bOldVer = false;
if( Parameters("DIR")->asGrid() == NULL )
{
bOldVer = Parameters("OLDVER")->asBool();
m_Dir_Const.x = sin(Parameters("DIR_CONST")->asDouble() * M_DEG_TO_RAD);
m_Dir_Const.y = cos(Parameters("DIR_CONST")->asDouble() * M_DEG_TO_RAD);
if( fabs(m_Dir_Const.x) > fabs(m_Dir_Const.y) )
{
m_Dir_Const.y /= fabs(m_Dir_Const.x);
m_Dir_Const.x = m_Dir_Const.x < 0 ? -1 : 1;
}
else
{
m_Dir_Const.x /= fabs(m_Dir_Const.y);
m_Dir_Const.y = m_Dir_Const.y < 0 ? -1 : 1;
}
}
else
{
if( !m_DX.Create(*Get_System()) || !m_DY.Create(*Get_System()) )
{
Error_Set(_TL("could not allocate sufficient memory"));
return( false );
}
CSG_Grid *pDir = Parameters("DIR")->asGrid();
CSG_Grid *pLen = Parameters("LEN")->asGrid();
double dRadians = Parameters("DIR_UNITS")->asInt() == 0 ? 1.0 : M_DEG_TO_RAD;
double dScale = Parameters("LEN_SCALE")->asDouble();
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( pDir->is_NoData(x, y) )
{
m_DX.Set_NoData(x, y);
}
else
{
double d = pLen ? (!pLen->is_NoData(x, y) ? dScale * pLen->asDouble(x, y) : 0.0) : 1.0;
m_DX.Set_Value(x, y, d * sin(pDir->asDouble(x, y) * dRadians));
m_DY.Set_Value(x, y, d * cos(pDir->asDouble(x, y) * dRadians));
}
}
}
}
if( Parameters("PYRAMIDS")->asBool() && !bOldVer )
{
m_DEM.Create(m_pDEM, 2.0);
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( m_pDEM->is_NoData(x, y) )
{
pAFH->Set_NoData(x, y);
}
else
{
double Luv, Luv_Lee, Lee;
if( bOldVer )
{
Get_Luv_Old(x, y, m_Dir_Const.x, m_Dir_Const.y, Luv);
Get_Lee_Old(x, y, -m_Dir_Const.x, -m_Dir_Const.y, Luv_Lee, Lee);
}
else
{
Get_Luv(x, y, Luv);
Get_Lee(x, y, Luv_Lee, Lee);
}
//-----------------------------------------
double d, z = m_pDEM->asDouble(x, y);
d = 1.0 + (z + Lee != 0.0 ? (z - Lee) / (z + Lee) : 0.0);
d = (Luv > Luv_Lee ? Luv - Luv_Lee : 0.0) + z * d*d / 2.0;
pAFH->Set_Value(x, y, d < 0.0 ? 0.0 : d);
}
}
}
//-----------------------------------------------------
m_DX .Destroy();
m_DY .Destroy();
m_DEM.Destroy();
return( true );
}
//---------------------------------------------------------
bool CCRU_Table_Import::On_Execute(void)
{
//-----------------------------------------------------
CSG_File File;
if( !File.Open(Parameters("FILE")->asString(), SG_FILE_R, false) )
{
Error_Fmt("%s [%s]", _TL("could not open file"), Parameters("FILE")->asString());
return( false );
}
//-----------------------------------------------------
CSG_String sLine;
if( !File.Read_Line(sLine) )
{
Error_Fmt("%s [%s]", _TL("failed to read header"), Parameters("FILE")->asString());
return( false );
}
//-----------------------------------------------------
int nx, ny, nMonths;
double Cellsize, xMin, yMin, xMax, yMax;
if( !File.Scan(Cellsize)
|| !File.Scan(xMin ) || !File.Scan(yMin )
|| !File.Scan(xMax ) || !File.Scan(yMax )
|| !File.Scan(nx ) || !File.Scan(ny )
|| !File.Scan(nMonths ) )
{
Error_Fmt("%s [%s]", _TL("failed to read header"), Parameters("FILE")->asString());
return( false );
}
//-----------------------------------------------------
CSG_Grid_System System(Cellsize, xMin, yMin, nx, ny);
if( !System.is_Valid() || System.Get_XMax() != xMax || System.Get_YMax() != yMax )
{
Error_Fmt("%s [%s]", _TL("failed to read header"), Parameters("FILE")->asString());
return( false );
}
//-----------------------------------------------------
bool bShift = Parameters("SHIFT")->asBool();
if( bShift )
{
System.Assign(Cellsize, xMin - 180.0, yMin, nx, ny);
}
//-----------------------------------------------------
CSG_String Name = SG_File_Get_Name(Parameters("FILE")->asString(), false);
Parameters("GRIDS")->asGridList()->Del_Items();
for(int iMonth=0; iMonth<nMonths && !File.is_EOF() && Process_Get_Okay(); iMonth++)
{
Process_Set_Text("%s %d", _TL("Band"), 1 + iMonth);
CSG_Grid *pGrid = SG_Create_Grid(System, SG_DATATYPE_Short);
pGrid->Fmt_Name("%s_%02d", Name.c_str(), 1 + iMonth);
pGrid->Set_NoData_Value(-9999);
pGrid->Get_Projection().Set_GCS_WGS84();
Parameters("GRIDS")->asGridList()->Add_Item(pGrid);
//-------------------------------------------------
for(int y=0; y<ny && !File.is_EOF() && Set_Progress(y, ny); y++)
{
if( File.Read_Line(sLine) && sLine.Length() >= 5. * nx )
{
for(int x=0, xx=bShift?nx/2:x, yy=ny-1-y; x<nx; x++, xx++)
{
double z;
CSG_String s = sLine.Mid(x * 5, 5);
if( s.asDouble(z) )
{
pGrid->Set_Value(xx % nx, yy, z);
}
else
{
pGrid->Set_NoData(xx % nx, yy);
}
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CFilter_3x3::On_Execute(void)
{
//-----------------------------------------------------
CSG_Table *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 );
}
//-----------------------------------------------------
CSG_Matrix Filter(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 nx = (Filter.Get_NX() - 1) / 2;
int ny = (Filter.Get_NY() - 1) / 2;
//-----------------------------------------------------
CSG_Grid *pInput = Parameters("INPUT" )->asGrid();
CSG_Grid *pResult = Parameters("RESULT")->asGrid();
if( !pResult || pResult == pInput )
{
pResult = SG_Create_Grid(pInput);
}
else
{
pResult->Fmt_Name("%s [%s]", pInput->Get_Name(), _TL("Filter"));
pResult->Set_NoData_Value(pInput->Get_NoData_Value());
}
//-----------------------------------------------------
bool bAbsolute = Parameters("ABSOLUTE")->asBool();
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-ny; iy<Filter.Get_NY(); iy++, jy++)
{
for(int ix=0, jx=x-nx; 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 );
}
//---------------------------------------------------------
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 CPresence_Prediction::On_Execute(void)
{
//-----------------------------------------------------
EventSet DL_Events ; m_DL_Events = &DL_Events ;
GISTrainer DL_Trainer; m_DL_Trainer = &DL_Trainer;
MaxEntModel DL_Model ; m_DL_Model = &DL_Model ;
m_YT_Model.clear();
//-----------------------------------------------------
CSG_Grid *pPrediction = Parameters("PREDICTION" )->asGrid();
CSG_Grid *pProbability = Parameters("PROBABILITY")->asGrid();
if( !pPrediction ->Get_Range() ) DataObject_Set_Colors(pPrediction , 11, SG_COLORS_YELLOW_GREEN);
if( !pProbability->Get_Range() ) DataObject_Set_Colors(pProbability, 11, SG_COLORS_YELLOW_GREEN);
m_Method = Parameters("METHOD" )->asInt ();
m_nNumClasses = Parameters("NUM_CLASSES" )->asInt ();
m_bYT_Weights = Parameters("YT_NUMASREAL")->asBool();
//-----------------------------------------------------
CSG_Array Features;
if( !Get_Features(Features) )
{
Error_Set(_TL("invalid features"));
return( false );
}
//-----------------------------------------------------
if( m_Method == 0 && SG_File_Exists(Parameters("YT_FILE_LOAD")->asString()) )
{
if( !Get_File(Parameters("YT_FILE_LOAD")->asString()) )
{
return( false );
}
}
else if( !Get_Training() )
{
return( false );
}
//-----------------------------------------------------
Process_Set_Text(_TL("prediction"));
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
int i;
CSG_Strings Values;
for(i=0; i<m_nFeatures; i++)
{
if( !m_Features[i].pGrid->is_NoData(x, y) )
{
Values.Add(Get_Feature(x, y, i));
}
else
{
break;
}
}
if( Values.Get_Count() != m_nFeatures )
{
pPrediction ->Set_NoData(x, y);
pProbability->Set_NoData(x, y);
}
else switch( m_Method )
{
//---------------------------------------------
default: // Kyoshida
{
ME_Sample Sample;
for(i=0; i<m_nFeatures; i++)
{
if( m_bYT_Weights && m_Features[i].bNumeric )
{
Sample.add_feature(m_Features[i].Name, m_Features[i].pGrid->asDouble(x, y));
}
else
{
Sample.add_feature(Values[i].b_str());
}
}
vector<double> Probs = m_YT_Model.classify(Sample);
pPrediction ->Set_Value(x, y, m_YT_Model.get_class_id(Sample.label) == 0 ? 1 : 0);
pProbability->Set_Value(x, y, Probs[0]);
}
break;
//---------------------------------------------
case 1: // Dekang Lin
{
MaxEntEvent Event; Event.count(1);
for(i=0; i<m_nFeatures; i++)
{
Event.push_back(m_DL_Trainer->getId(Values[i].b_str()));
}
vector<double> Probs;
pPrediction ->Set_Value(x, y, m_DL_Model->getProbs(Event, Probs) == 0 ? 1 : 0);
pProbability->Set_Value(x, y, Probs[0]);
}
break;
}
}
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Calculator::On_Execute(void)
{
double Result, *Values;
CSG_Formula Formula;
CSG_Parameter_Grid_List *pGrids;
CSG_Grid *pResult;
//-----------------------------------------------------
pResult = Parameters("RESULT") ->asGrid();
pGrids = Parameters("GRIDS") ->asGridList();
//-----------------------------------------------------
if( pGrids->Get_Count() <= 0 )
{
Message_Add(_TL("No grid in list"));
return( false );
}
//-----------------------------------------------------
if( !Formula.Set_Formula(Parameters("FORMULA")->asString()) )
{
int Position;
CSG_String Message, s;
s += _TL("Error in formula");
s += SG_T("\n") + Formula.Get_Formula();
if( Formula.Get_Error(&Position, &Message) )
{
s += SG_T("\n") + Message;
s += CSG_String::Format(SG_T("\n%s: %d"), _TL("Position") , Position);
if( Position >= 0 && Position < (int)Formula.Get_Formula().Length() )
{
s += SG_T("\n")
+ Formula.Get_Formula().Left(Position - 1) + SG_T("[")
+ Formula.Get_Formula()[Position] + SG_T("]")
+ Formula.Get_Formula().Right(Formula.Get_Formula().Length() - (Position + 1));
}
}
Message_Add(s, false);
return( false );
}
//-----------------------------------------------------
pResult->Set_Name(Formula.Get_Formula());
Values = new double[pGrids->Get_Count()];
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
bool bNoData = false;
for(int i=0; i<pGrids->Get_Count() && !bNoData; i++)
{
if( pGrids->asGrid(i)->is_NoData(x, y) )
{
bNoData = true;
}
else
{
Values[i] = pGrids->asGrid(i)->asDouble(x, y);
}
}
if( bNoData || _finite(Result = Formula.Get_Value(Values, pGrids->Get_Count())) == false )
{
pResult->Set_NoData(x, y);
}
else
{
pResult->Set_Value(x, y, Result);
}
}
}
delete[](Values);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CTC_Classification::On_Execute(void)
{
//-----------------------------------------------------
m_pSlope = Parameters("SLOPE" )->asGrid();
m_pConvexity = Parameters("CONVEXITY")->asGrid();
m_pTexture = Parameters("TEXTURE" )->asGrid();
if( (!m_pSlope || !m_pConvexity || !m_pTexture) && !Parameters("DEM")->asGrid() )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid Slope;
if( !m_pSlope )
{
Slope.Create(*Get_System()); m_pSlope = &Slope;
CSG_Grid *pDEM = Parameters("DEM")->asGrid();
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, a;
if( pDEM->Get_Gradient(x, y, s, a) )
{
Slope.Set_Value(x, y, s);
}
else
{
Slope.Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
if( !m_pConvexity || Parameters("CONV_RECALC")->asBool() )
{
CTC_Convexity c;
c.Set_Parameter( "DEM", Parameters("DEM"));
c.Set_Parameter( "SCALE", Parameters("CONV_SCALE"));
c.Set_Parameter( "KERNEL", Parameters("CONV_KERNEL"));
c.Set_Parameter( "TYPE", Parameters("CONV_TYPE"));
c.Set_Parameter( "EPSILON", Parameters("CONV_EPSILON"));
c.Set_Parameter("CONVEXITY", m_pConvexity);
if( !c.Execute() )
{
return( false );
}
Parameters("CONVEXITY")->Set_Value(m_pConvexity = c.Get_Parameters()->Get_Parameter("CONVEXITY")->asGrid());
}
//-----------------------------------------------------
if( !m_pTexture || Parameters("TEXT_RECALC")->asBool() )
{
CTC_Texture c;
c.Set_Parameter( "DEM", Parameters("DEM"));
c.Set_Parameter( "SCALE", Parameters("TEXT_SCALE"));
c.Set_Parameter("EPSILON", Parameters("TEXT_EPSILON"));
c.Set_Parameter("TEXTURE", m_pTexture);
if( !c.Execute() )
{
return( false );
}
Parameters("TEXTURE")->Set_Value(m_pTexture = c.Get_Parameters()->Get_Parameter("TEXTURE")->asGrid());
}
//-----------------------------------------------------
return( Get_Classes() );
}
//---------------------------------------------------------
bool CKriging_Regression::On_Execute(void)
{
//-----------------------------------------------------
CSG_Shapes Points(SHAPE_TYPE_Point);
CSG_Grid *pPrediction = Parameters("PREDICTION")->asGrid();
CSG_Grid *pRegression = Parameters("REGRESSION")->asGrid();
CSG_Grid *pResiduals = Parameters("RESIDUALS" )->asGrid();
CSG_Grid *pVariance = Parameters("VARIANCE" )->asGrid();
//-----------------------------------------------------
if( !pResiduals )
{
pResiduals = pPrediction;
}
//-----------------------------------------------------
SG_RUN_MODULE_ExitOnError("statistics_regression", 1, // Multiple Regression Analysis (Points and Predictor Grids)
SG_MODULE_PARAMETER_SET("PREDICTORS", Parameters("PREDICTORS"))
&& SG_MODULE_PARAMETER_SET("POINTS" , Parameters("POINTS" ))
&& SG_MODULE_PARAMETER_SET("ATTRIBUTE" , Parameters("FIELD" ))
&& SG_MODULE_PARAMETER_SET("INFO_COEFF", Parameters("INFO_COEFF"))
&& SG_MODULE_PARAMETER_SET("INFO_MODEL", Parameters("INFO_MODEL"))
&& SG_MODULE_PARAMETER_SET("INFO_STEPS", Parameters("INFO_STEPS"))
&& SG_MODULE_PARAMETER_SET("RESAMPLING", Parameters("RESAMPLING"))
&& SG_MODULE_PARAMETER_SET("COORD_X" , Parameters("COORD_X" ))
&& SG_MODULE_PARAMETER_SET("COORD_Y" , Parameters("COORD_Y" ))
&& SG_MODULE_PARAMETER_SET("INTERCEPT" , Parameters("INTERCEPT" ))
&& SG_MODULE_PARAMETER_SET("METHOD" , Parameters("METHOD" ))
&& SG_MODULE_PARAMETER_SET("P_VALUE" , Parameters("P_VALUE" ))
&& SG_MODULE_PARAMETER_SET("REGRESSION", pRegression)
&& SG_MODULE_PARAMETER_SET("RESIDUALS" , &Points )
);
//-----------------------------------------------------
Process_Set_Text(m_OK.Get_Name());
m_OK.Set_Manager(NULL);
if( !m_OK.Set_Parameter("POINTS" , &Points)
|| !m_OK.Set_Parameter("FIELD" , 2) // residual
|| !m_OK.Set_Parameter("LOG" , Parameters("LOG" ))
|| !m_OK.Set_Parameter("BLOCK" , Parameters("BLOCK" ))
|| !m_OK.Set_Parameter("DBLOCK" , Parameters("DBLOCK" ))
|| !m_OK.Set_Parameter("SEARCH_RANGE" , Parameters("SEARCH_RANGE" ))
|| !m_OK.Set_Parameter("SEARCH_RADIUS" , Parameters("SEARCH_RADIUS" ))
|| !m_OK.Set_Parameter("SEARCH_POINTS_ALL", Parameters("SEARCH_POINTS_ALL"))
|| !m_OK.Set_Parameter("SEARCH_POINTS_MIN", Parameters("SEARCH_POINTS_MIN"))
|| !m_OK.Set_Parameter("SEARCH_POINTS_MAX", Parameters("SEARCH_POINTS_MAX"))
|| !m_OK.Set_Parameter("SEARCH_DIRECTION" , Parameters("SEARCH_DIRECTION" ))
|| !m_OK.Set_Parameter("TARGET_DEFINITION", 1) // grid or grid system
|| !m_OK.Set_Parameter("PREDICTION" , pResiduals)
|| !m_OK.Set_Parameter("VARIANCE" , pVariance )
|| (!SG_UI_Get_Window_Main() && ( // saga_cmd
!m_OK.Set_Parameter("VAR_MAXDIST" , Parameters("VAR_MAXDIST" ))
|| !m_OK.Set_Parameter("VAR_NCLASSES" , Parameters("VAR_NCLASSES" ))
|| !m_OK.Set_Parameter("VAR_NSKIP" , Parameters("VAR_NSKIP" ))
|| !m_OK.Set_Parameter("VAR_MODEL" , Parameters("VAR_MODEL" )))) )
{
Error_Set(CSG_String::Format(SG_T("%s [%s].[%s]"), _TL("could not initialize tool"), SG_T("statistics_regression"), m_OK.Get_Name().c_str()));
return( false );
}
if( !m_OK.Execute() )
{
Error_Set(CSG_String::Format(SG_T("%s [%s].[%s]"), _TL("could not execute tool"), SG_T("statistics_regression"), m_OK.Get_Name().c_str()));\
return( false );
}
//-----------------------------------------------------
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( pRegression->is_NoData(x, y) || pResiduals->is_NoData(x, y) )
{
pPrediction->Set_NoData(x, y);
}
else
{
pPrediction->Add_Value(x, y, pRegression->asDouble(x, y) + pResiduals->asDouble(x, y));
}
}
}
//-----------------------------------------------------
pRegression->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Regression")));
pPrediction->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Prediction")));
if( Parameters("RESIDUALS")->asGrid() )
{
pResiduals->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Residuals")));
}
if( pVariance )
{
pVariance ->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Quality")));
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
CSG_Shape * CWatersheds_ext::Get_Basin(CSG_Grid *pBasins, CSG_Shapes *pPolygons)
{
int x, y, nEdges, Basin_ID;
CSG_Grid Edge;
CSG_Shape *pPolygon = NULL;
Basin_ID = 1 + pPolygons->Get_Count();
//-----------------------------------------------------
Edge.Create(SG_DATATYPE_Char, 2 * Get_NX() + 1, 2 * Get_NY() + 1, 0.5 * Get_Cellsize(), Get_XMin() - 0.5 * Get_Cellsize(), Get_YMin() - 0.5 * Get_Cellsize());
Edge.Set_NoData_Value(0);
for(y=0, nEdges=0; y<Get_NY() && Process_Get_Okay(); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( pBasins->asInt(x, y) == Basin_ID )
{
for(int i=0; i<8; i+=2)
{
int ix = Get_xTo(i, x);
int iy = Get_yTo(i, y);
if( !is_InGrid(ix, iy) || pBasins->asInt(ix, iy) != Basin_ID )
{
ix = 1 + 2 * x;
iy = 1 + 2 * y;
Edge.Set_Value( ix, iy , 1);
Edge.Set_Value(Get_xTo(i , ix), Get_yTo(i , iy), -1);
Edge.Set_Value(Get_xTo(i - 1, ix), Get_yTo(i - 1, iy), -1);
nEdges++;
}
}
}
}
}
//-----------------------------------------------------
if( nEdges > 0 )
{
for(int yEdge=0; yEdge<Edge.Get_NY(); yEdge++) for(int xEdge=0; xEdge<Edge.Get_NX(); xEdge++)
{
int i = 4;
if( Edge.asInt(xEdge, yEdge) == 1 && Edge.asInt(Get_xTo(i, xEdge), Get_yTo(i, yEdge)) == -1 )
{
if( pPolygon == NULL )
{
pPolygon = pPolygons->Add_Shape();
}
int iPart = pPolygon->Get_Part_Count();
int xFirst = x = Get_xTo(i, xEdge);
int yFirst = y = Get_yTo(i, yEdge);
i = i + 2;
pPolygon ->Add_Point(Edge.Get_System().Get_Grid_to_World(x, y), iPart);
do
{
int ix = Get_xTo(i + 2, x);
int iy = Get_yTo(i + 2, y);
if( Edge.is_InGrid(ix, iy) && Edge.asInt(ix, iy) == -1 ) // go right ?
{
pPolygon->Add_Point(Edge.Get_System().Get_Grid_to_World(x, y), iPart);
i = (i + 2) % 8;
}
else
{
if( Edge.asInt(ix, iy) == 1 )
{
Edge.Set_NoData(ix, iy); // erase class id in right cells
}
ix = Get_xTo(i, x);
iy = Get_yTo(i, y);
if( Edge.is_InGrid(ix, iy) && Edge.asInt(ix, iy) == -1 ) // go ahead ?
{
// nop
}
else
{
ix = Get_xTo(i + 6, x);
iy = Get_yTo(i + 6, y);
if( Edge.is_InGrid(ix, iy) && Edge.asInt(ix, iy) == -1 ) // go left ?
{
pPolygon->Add_Point(Edge.Get_System().Get_Grid_to_World(x, y), iPart);
i = (i + 6) % 8;
}
else
{
return( false );
}
}
}
x = ix;
y = iy;
}
while( x != xFirst || y != yFirst );
pPolygon->Add_Point(Edge.Get_System().Get_Grid_to_World(x, y), iPart);
}
}
}
//-----------------------------------------------------
return( pPolygon );
}
//---------------------------------------------------------
bool CGrid_RGB_Composite::On_Execute(void)
{
double rMin, rRange, gMin, gRange, bMin, bRange, aMin, aRange;
//-----------------------------------------------------
CSG_Grid *pR = _Get_Grid(Parameters("R_GRID")->asGrid(), Parameters("R_METHOD")->asInt(), Parameters("R_RANGE")->asRange(), Parameters("R_PERCTL")->asRange(), Parameters("R_STDDEV")->asDouble(), rMin, rRange);
CSG_Grid *pG = _Get_Grid(Parameters("G_GRID")->asGrid(), Parameters("G_METHOD")->asInt(), Parameters("G_RANGE")->asRange(), Parameters("G_PERCTL")->asRange(), Parameters("G_STDDEV")->asDouble(), gMin, gRange);
CSG_Grid *pB = _Get_Grid(Parameters("B_GRID")->asGrid(), Parameters("B_METHOD")->asInt(), Parameters("B_RANGE")->asRange(), Parameters("B_PERCTL")->asRange(), Parameters("B_STDDEV")->asDouble(), bMin, bRange);
CSG_Grid *pA = _Get_Grid(Parameters("A_GRID")->asGrid(), Parameters("A_METHOD")->asInt(), Parameters("A_RANGE")->asRange(), Parameters("A_PERCTL")->asRange(), Parameters("A_STDDEV")->asDouble(), aMin, aRange);
//-----------------------------------------------------
CSG_Grid *pRGB = Parameters("RGB")->asGrid();
pRGB->Create(pRGB->Get_System(), SG_DATATYPE_Int);
pRGB->Set_Name(_TL("Composite"));
CSG_String s;
s += CSG_String(_TL("Red" )) + ": " + pR->Get_Name() + "\n";
s += CSG_String(_TL("Green")) + ": " + pG->Get_Name() + "\n";
s += CSG_String(_TL("Blue" )) + ": " + pB->Get_Name() + "\n";
if( pA )
{
s += CSG_String(_TL("Alpha")) + ": " + pA->Get_Name() + "\n";
}
pRGB->Set_Description(s);
DataObject_Set_Colors (pRGB, 100, SG_COLORS_BLACK_WHITE);
DataObject_Set_Parameter(pRGB, "COLORS_TYPE", 5); // Color Classification Type: RGB Coded Values
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pR->is_NoData(x, y) || pG->is_NoData(x, y) || pB->is_NoData(x, y) || (pA && pA->is_NoData(x, y)) )
{
pRGB->Set_NoData(x, y);
}
else
{
int r = (int)(rRange * (pR->asDouble(x, y) - rMin)); if( r > 255 ) r = 255; else if( r < 0 ) r = 0;
int g = (int)(gRange * (pG->asDouble(x, y) - gMin)); if( g > 255 ) g = 255; else if( g < 0 ) g = 0;
int b = (int)(bRange * (pB->asDouble(x, y) - bMin)); if( b > 255 ) b = 255; else if( b < 0 ) b = 0;
if( pA )
{
int a = (int)(aRange * (pA->asDouble(x, y) - aMin)); if( a > 255 ) a = 255; else if( a < 0 ) a = 0;
pRGB->Set_Value(x, y, SG_GET_RGBA(r, g, b, a));
}
else
{
pRGB->Set_Value(x, y, SG_GET_RGB (r, g, b));
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CWindeffect_Correction::On_Execute(void)
{
//-----------------------------------------------------
m_pBoundary = Parameters("BOUNDARY")->asGrid();
m_pWind = Parameters("WIND" )->asGrid();
m_pObserved = Parameters("OBSERVED")->asGrid();
CSG_Grid *pWindCorr = Parameters("WINDCORR")->asGrid();
//-----------------------------------------------------
if( Parameters("B_SOURCE")->asInt() == 0 ) // constant
{
double B = Parameters("B_CONST")->asDouble();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( m_pWind->is_NoData(x, y) || m_pBoundary->is_NoData(x, y) )
{
pWindCorr->Set_NoData(x, y);
}
else
{
pWindCorr->Set_Value(x, y, Get_Wind_Corr(B, m_pBoundary->asDouble(x, y), m_pWind->asDouble(x, y)));
}
}
}
}
//-----------------------------------------------------
else
{
CSG_Grid *pB = Parameters("B_GRID")->asGrid();
DataObject_Set_Colors(pB, 11, SG_COLORS_WHITE_GREEN);
double B_min = 0.0;
double B_max = Parameters("B_MAX")->asDouble();
double B_Step = (B_max - B_min) / Parameters("B_STEPS")->asDouble();
m_Kernel.Set_Radius(Parameters("KERNEL_SIZE")->asInt(), Parameters("KERNEL_TYPE")->asInt() == 0);
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#ifndef _DEBUG
#pragma omp parallel for
#endif
for(int x=0; x<Get_NX(); x++)
{
double B;
if( !Fit_Scaling_Factor(x, y, B, B_min, B_max, B_Step) )
{
pB ->Set_NoData(x, y);
pWindCorr->Set_NoData(x, y);
}
else
{
pB ->Set_Value(x, y, B);
pWindCorr->Set_Value(x, y, Get_Wind_Corr(B, m_pBoundary->asDouble(x, y), m_pWind->asDouble(x, y)));
}
}
}
m_Kernel.Destroy();
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGrid_Value_Type::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pOutput = Parameters("OUTPUT")->asGrid();
CSG_Grid *pInput = Parameters("INPUT" )->asGrid(), Input;
if( pOutput == NULL || pOutput == pInput )
{
Input.Create(*pInput);
pOutput = pInput;
pInput = &Input;
}
//-----------------------------------------------------
double Offset = Parameters("OFFSET")->asDouble();
double Scale = Parameters("SCALE" )->asDouble();
if( Scale == 0.0 )
{
Error_Set(_TL("scale factor must not equal zero"));
return( false );
}
//-----------------------------------------------------
switch( Parameters("TYPE")->asInt() )
{
default:
Error_Set(_TL("undefined data type"));
return( false );
case 0: pOutput->Create(*Get_System(), SG_DATATYPE_Bit ); break;
case 1: pOutput->Create(*Get_System(), SG_DATATYPE_Byte ); break;
case 2: pOutput->Create(*Get_System(), SG_DATATYPE_Char ); break;
case 3: pOutput->Create(*Get_System(), SG_DATATYPE_Word ); break;
case 4: pOutput->Create(*Get_System(), SG_DATATYPE_Short ); break;
case 5: pOutput->Create(*Get_System(), SG_DATATYPE_DWord ); break;
case 6: pOutput->Create(*Get_System(), SG_DATATYPE_Int ); break;
case 7: pOutput->Create(*Get_System(), SG_DATATYPE_Float ); break;
case 8: pOutput->Create(*Get_System(), SG_DATATYPE_Double); break;
}
pOutput->Set_Name (pInput->Get_Name ());
pOutput->Set_Description(pInput->Get_Description());
pOutput->Set_Unit (pInput->Get_Unit ());
pOutput->Set_Scaling (Scale, Offset);
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pInput->is_NoData(x, y) )
{
pOutput->Set_NoData(x, y);
}
else
{
pOutput->Set_Value(x, y, pInput->asDouble(x, y));
}
}
}
//-----------------------------------------------------
if( pOutput == Parameters("INPUT")->asGrid() )
{
DataObject_Update(pOutput);
}
return( true );
}
//---------------------------------------------------------
bool CFilter::On_Execute(void)
{
int x, y, Mode, Radius, Method;
double Mean;
CSG_Grid *pResult;
//-----------------------------------------------------
m_pInput = Parameters("INPUT") ->asGrid();
pResult = Parameters("RESULT") ->asGrid();
Radius = Parameters("RADIUS") ->asInt();
Mode = Parameters("MODE") ->asInt();
Method = Parameters("METHOD") ->asInt();
if( !pResult || pResult == m_pInput )
{
pResult = SG_Create_Grid(m_pInput);
Parameters("RESULT")->Set_Value(m_pInput);
}
pResult->Set_NoData_Value(m_pInput->Get_NoData_Value());
switch( Mode )
{
case 0: break;
case 1: m_Radius.Create(Radius); break;
}
//-----------------------------------------------------
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(x=0; x<Get_NX(); x++)
{
if( !m_pInput->is_InGrid(x, y) )
{
pResult->Set_NoData(x, y);
}
else
{
switch( Mode )
{
case 0: Mean = Get_Mean_Square(x, y, Radius); break;
case 1: Mean = Get_Mean_Circle(x, y); break;
}
switch( Method )
{
case 0: default: // Smooth...
pResult->Set_Value(x, y, Mean);
break;
case 1: // Sharpen...
pResult->Set_Value(x, y, m_pInput->asDouble(x, y) + (m_pInput->asDouble(x, y) - Mean));
break;
case 2: // Edge...
pResult->Set_Value(x, y, m_pInput->asDouble(x, y) - Mean);
break;
}
}
}
}
//-----------------------------------------------------
if( m_pInput == Parameters("RESULT")->asGrid() )
{
m_pInput->Assign(pResult);
delete(pResult);
}
m_Radius.Destroy();
return( true );
}