//---------------------------------------------------------
bool CSG_Grid_Pyramid::_Get_Next_Level(CSG_Grid *pGrid)
{
if( (m_nMaxLevels <= 0 || m_nLevels < m_nMaxLevels) )
{
int nx, ny;
double Cellsize;
switch( m_Grow_Type )
{
case GRID_PYRAMID_Arithmetic: Cellsize = pGrid->Get_Cellsize() + m_Grow; break;
case GRID_PYRAMID_Geometric: Cellsize = pGrid->Get_Cellsize() * m_Grow; break;
default: Cellsize = pGrid->Get_Cellsize() * m_Grow; break;
}
nx = (int)(1.5 + m_pGrid->Get_XRange() / Cellsize); if( nx < 1 ) nx = 1;
ny = (int)(1.5 + m_pGrid->Get_YRange() / Cellsize); if( ny < 1 ) ny = 1;
if( nx > 1 || ny > 1 )
{
CSG_Grid *pNext = SG_Create_Grid(SG_DATATYPE_Float, nx, ny, Cellsize, pGrid->Get_XMin(), pGrid->Get_YMin());
pNext->Set_NoData_Value(pGrid->Get_NoData_Value());
pNext->Assign(pGrid);
m_pLevels = (CSG_Grid **)SG_Realloc(m_pLevels, (m_nLevels + 1) * sizeof(CSG_Grid *));
m_pLevels[m_nLevels++] = pNext;
_Get_Next_Level(pNext);
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CSG_Grid_Pyramid::_Get_Next_Level(CSG_Grid *pGrid, double Cellsize)
{
if( (m_nMaxLevels <= 0 || m_nLevels < m_nMaxLevels) )
{
int nx, ny;
nx = (int)(1.5 + m_pGrid->Get_XRange() / Cellsize); if( nx < 1 ) nx = 1;
ny = (int)(1.5 + m_pGrid->Get_YRange() / Cellsize); if( ny < 1 ) ny = 1;
if( nx > 1 || ny > 1 )
{
CSG_Grid *pNext = SG_Create_Grid(SG_DATATYPE_Float, nx, ny, Cellsize, pGrid->Get_XMin(), pGrid->Get_YMin());
pNext->Set_NoData_Value(pGrid->Get_NoData_Value());
pNext->Assign(pGrid);
m_pLevels = (CSG_Grid **)SG_Realloc(m_pLevels, (m_nLevels + 1) * sizeof(CSG_Grid *));
m_pLevels[m_nLevels++] = pNext;
_Get_Next_Level(pNext);
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CWatershed_Segmentation::Get_Borders(void)
{
Process_Set_Text(_TL("Borders"));
CSG_Grid *pBorders = SG_Create_Grid(SG_DATATYPE_Byte, Get_NX() + 2, Get_NY() + 2, Get_Cellsize(), Get_XMin() - 0.5 * Get_Cellsize(), Get_YMin() - 0.5 * Get_Cellsize());
pBorders->Set_NoData_Value(0);
Parameters("BORDERS")->Set_Value(pBorders);
for(int y=0, yy=1; yy<Get_NY() && Set_Progress(yy); y++, yy++)
{
for(int x=0, xx=1; xx<Get_NX(); x++, xx++)
{
int id = m_pSegments->asInt(x, y);
if( id != m_pSegments->asInt(xx, y) )
{
pBorders->Set_Value(xx, y, 1);
}
if( id != m_pSegments->asInt( x, yy) )
{
pBorders->Set_Value( x, yy, 1);
}
if( id != m_pSegments->asInt(xx, yy) )
{
pBorders->Set_Value(xx, yy, 1);
}
}
}
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 CSRTM30_Import::On_Execute(void)
{
char x_sTile[9][5] = { "W180", "W140", "W100", "W060", "W020", "E020", "E060", "E100", "E140" },
y_sTile[3][4] = { "S10", "N40", "N90" };
double dSize = 30.0 / (60.0 * 60.0);
//-----------------------------------------------------
int xTile, yTile;
double xMin, xMax, yMin, yMax;
TSG_Rect rOut, rTile;
CSG_String sTile;
CSG_Grid *pOut;
//-----------------------------------------------------
xMin = Parameters("XMIN")->asInt();
xMax = Parameters("XMAX")->asInt();
yMin = Parameters("YMIN")->asInt();
yMax = Parameters("YMAX")->asInt();
rOut.xMin = (180 + xMin) / 40.0 * X_WIDTH;
rOut.xMax = rOut.xMin + (int)((xMax - xMin) / dSize);
rOut.yMin = ( 60 + yMin) / 50.0 * Y_WIDTH;
rOut.yMax = rOut.yMin + (int)((yMax - yMin) / dSize);
//-----------------------------------------------------
pOut = SG_Create_Grid(SG_DATATYPE_Short,
(int)(rOut.xMax - rOut.xMin),
(int)(rOut.yMax - rOut.yMin),
dSize,
xMin + 0.5 * dSize,
yMin + 0.5 * dSize
);
pOut->Set_NoData_Value(-9999);
pOut->Assign_NoData();
pOut->Set_Name(SG_T("SRTM30"));
pOut->Get_Projection().Create(SG_T("GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY[\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.01745329251994328,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4326\"]]"));
//-----------------------------------------------------
for(yTile=0, rTile.yMin=0, rTile.yMax=Y_WIDTH; yTile<3; yTile++, rTile.yMin+=Y_WIDTH, rTile.yMax+=Y_WIDTH)
{
for(xTile=0, rTile.xMin=0, rTile.xMax=X_WIDTH; xTile<9; xTile++, rTile.xMin+=X_WIDTH, rTile.xMax+=X_WIDTH)
{
sTile.Printf(SG_T("Tile: %s%s"), x_sTile[xTile], y_sTile[yTile]);
Process_Set_Text(sTile);
sTile.Printf(SG_T("%s%s%s.dem"), Parameters("PATH")->asString(), x_sTile[xTile], y_sTile[yTile]);
Tile_Load(sTile, rTile, pOut, rOut);
}
}
//-----------------------------------------------------
Parameters("GRID")->Set_Value(pOut);
return( true );
}
//---------------------------------------------------------
bool CGrid_Classify_Supervised::On_Execute(void)
{
//-----------------------------------------------------
if( !Get_Features() )
{
Error_Set(_TL("invalid features"));
return( false );
}
//-----------------------------------------------------
CSG_Classifier_Supervised Classifier;
if( !Set_Classifier(Classifier) )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pClasses = Parameters("CLASSES")->asGrid();
CSG_Grid *pQuality = Parameters("QUALITY")->asGrid();
pClasses->Set_NoData_Value(0);
pClasses->Assign(0.0);
//-----------------------------------------------------
Process_Set_Text(_TL("prediction"));
int Method = Parameters("METHOD")->asInt();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
int Class;
double Quality;
CSG_Vector Features(m_pFeatures->Get_Count());
if( Get_Features(x, y, Features) && Classifier.Get_Class(Features, Class, Quality, Method) )
{
SG_GRID_PTR_SAFE_SET_VALUE(pClasses, x, y, 1 + Class);
SG_GRID_PTR_SAFE_SET_VALUE(pQuality, x, y, Quality );
}
else
{
SG_GRID_PTR_SAFE_SET_NODATA(pClasses, x, y);
SG_GRID_PTR_SAFE_SET_NODATA(pQuality, x, y);
}
}
}
//-----------------------------------------------------
return( Set_Classification(Classifier) );
}
//---------------------------------------------------------
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 CTC_Classification::Get_Classes(void)
{
//-----------------------------------------------------
int Level, nLevels = 1 + Parameters("TYPE")->asInt();
CSG_Grid *pLandforms = Parameters("LANDFORMS")->asGrid();
pLandforms->Assign(0.0);
pLandforms->Set_NoData_Value(CLASS_FLAG_NODATA);
Set_LUT(pLandforms, nLevels);
//-----------------------------------------------------
for(Level=1; Level<=nLevels && Process_Get_Okay(); Level++)
{
Process_Set_Text(CSG_String::Format("%s: %d", _TL("Level"), Level));
m_Mean_Slope = Level == 1 ? m_pSlope ->Get_Mean() : m_Stat_Slope .Get_Mean();
m_Mean_Convexity = Level == 1 ? m_pConvexity->Get_Mean() : m_Stat_Convexity.Get_Mean();
m_Mean_Texture = Level == 1 ? m_pTexture ->Get_Mean() : m_Stat_Texture .Get_Mean();
m_Stat_Slope .Invalidate();
m_Stat_Convexity.Invalidate();
m_Stat_Texture .Invalidate();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( pLandforms->asInt(x, y) == 0 )
{
pLandforms->Set_Value(x, y, Get_Class(Level, x, y, Level == nLevels));
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSoil_Texture::On_Execute(void)
{
//-----------------------------------------------------
CSG_Grid *pSand = Parameters("SAND" )->asGrid();
CSG_Grid *pSilt = Parameters("SILT" )->asGrid();
CSG_Grid *pClay = Parameters("CLAY" )->asGrid();
CSG_Grid *pClass = Parameters("TEXTURE")->asGrid();
CSG_Grid *pSum = Parameters("SUM" )->asGrid();
//-----------------------------------------------------
if( (pSand ? 1 : 0) + (pSilt ? 1 : 0) + (pClay ? 1 : 0) < 2 )
{
Error_Set(_TL("at least two contents (sand, silt, clay) have to be given"));
return( false );
}
//-----------------------------------------------------
pClass->Set_NoData_Value(-1.0);
CSG_Parameter *pLUT = DataObject_Get_Parameter(pClass, "LUT");
if( pLUT && pLUT->asTable() )
{
CSG_Table *pClasses = pLUT->asTable();
for(int iClass=0; iClass<12; iClass++)
{
CSG_Table_Record *pClass = pClasses->Get_Record(iClass);
if( pClass == NULL )
{
pClass = pClasses->Add_Record();
}
pClass->Set_Value(0, Classes[iClass].Color);
pClass->Set_Value(1, Classes[iClass].Name);
pClass->Set_Value(2, Classes[iClass].Key);
pClass->Set_Value(3, iClass);
pClass->Set_Value(4, iClass);
}
while( pClasses->Get_Count() > 12 )
{
pClasses->Del_Record(pClasses->Get_Count() - 1);
}
DataObject_Set_Parameter(pClass, pLUT); // Lookup Table
DataObject_Set_Parameter(pClass, "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++)
{
if( (pSand && pSand->is_NoData(x, y))
|| (pSilt && pSilt->is_NoData(x, y))
|| (pClay && pClay->is_NoData(x, y)) )
{
SG_GRID_PTR_SAFE_SET_NODATA(pClass, x, y);
SG_GRID_PTR_SAFE_SET_NODATA(pSum , x, y);
}
else
{
int Class = -1;
double Sum = 100.0;
if( pSand && pSilt && pClay )
{
Class = Get_Texture(pSand->asDouble(x, y), pSilt->asDouble(x, y), pClay->asDouble(x, y), Sum);
}
else if( !pSilt )
{
Class = Get_Texture_SandClay(pSand->asDouble(x, y), pClay->asDouble(x, y));
}
else if( !pClay )
{
Class = Get_Texture_SandSilt(pSand->asDouble(x, y), pSilt->asDouble(x, y));
}
else if( !pSand )
{
Class = Get_Texture_SiltClay(pSilt->asDouble(x, y), pClay->asDouble(x, y));
}
SG_GRID_PTR_SAFE_SET_VALUE(pClass, x, y, Class);
SG_GRID_PTR_SAFE_SET_VALUE(pSum , x, y, Sum );
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CMOLA_Import::On_Execute(void)
{
bool bDown;
int xa, xb, y, yy, NX, NY;
short *sLine;
double D, xMin, yMin;
CSG_File Stream;
TSG_Data_Type Type;
CSG_Grid *pGrid;
CSG_String fName, sName;
//-----------------------------------------------------
pGrid = NULL;
switch( Parameters("TYPE")->asInt() )
{
case 0: Type = SG_DATATYPE_Short; break;
case 1: default: Type = SG_DATATYPE_Float; break;
}
bDown = Parameters("ORIENT")->asInt() == 1;
//-----------------------------------------------------
// MEGpxxnyyyrv
// 012345678901
// p indicates the product type (A for areoid, C for counts, R for
// radius, and T for topography)
// xx is the latitude of the upper left corner of the image
// n indicates whether the latitude is north (N) or south (S)
// yyy is the east longitude of the upper left corner of the image
// r is the map resolution using the pattern
// c = 4 pixel per degree
// e = 16 pixel per degree
// f = 32 pixel per degree
// g = 64 pixel per degree
// h = 128 pixel per degree
// (This convention is consistent with that used for the Mars Digital
// Image Model [MDIM] archives.)
// v is a letter indicating the product version.
fName = SG_File_Get_Name(Parameters("FILE")->asString(), false);
fName.Make_Upper();
if( fName.Length() < 12 )
{
return( false );
}
//-----------------------------------------------------
switch( fName[3] )
{
default:
return( false );
case 'A':
sName.Printf(SG_T("MOLA: Areoid v%c") , fName[11]);
break;
case 'C':
sName.Printf(SG_T("MOLA: Counts v%c") , fName[11]);
break;
case 'R':
sName.Printf(SG_T("MOLA: Radius v%c") , fName[11]);
break;
case 'T':
sName.Printf(SG_T("MOLA: Topography v%c") , fName[11]);
break;
}
//-----------------------------------------------------
switch( fName[10] )
{
default:
return( false );
case 'C': // 1/4th degree...
D = 1.0 / 4.0;
NX = 4 * 360;
NY = 4 * 180;
yMin = - 90.0;
xMin = -180.0;
break;
case 'D': // 1/8th degree...
D = 1.0 / 8.0;
NX = 8 * 360;
NY = 8 * 180;
yMin = - 90.0;
xMin = -180.0;
break;
case 'E': // 1/16th degree...
D = 1.0 / 16.0;
NX = 16 * 360;
NY = 16 * 180;
yMin = - 90.0;
xMin = -180.0;
break;
case 'F': // 1/32th degree...
D = 1.0 / 32.0;
NX = 32 * 360;
NY = 32 * 180;
yMin = - 90.0;
xMin = -180.0;
break;
case 'G': // 1/64th degree...
D = 1.0 / 64.0;
NX = 64 * 180;
NY = 64 * 90;
yMin = (fName[6] == 'S' ? -1.0 : 1.0) * fName.Right(8).asInt();
yMin = bDown ? yMin - NY * D : -yMin;
xMin = fName.Right(5).asInt();
if( xMin >= 180.0 )
{
xMin -= 360.0;
}
break;
case 'H': // 1/128th degree...
D = 1.0 / 128.0;
NX = 128 * 90;
NY = 128 * 44;
yMin = (fName[6] == 'S' ? -1.0 : 1.0) * fName.Right(8).asInt();
yMin = bDown ? yMin - NY * D : -yMin;
xMin = fName.Right(5).asInt();
if( xMin >= 180.0 )
{
xMin -= 360.0;
}
break;
}
//-----------------------------------------------------
if( Stream.Open(Parameters("FILE")->asString(), SG_FILE_R, true) )
{
if( (pGrid = SG_Create_Grid(Type, NX, NY, D, xMin + D / 2.0, yMin + D / 2.0)) != NULL )
{
pGrid->Set_Name(sName);
pGrid->Set_NoData_Value(-999999);
pGrid->Get_Projection().Create(SG_T("+proj=lonlat +units=m +a=3396200.000000 +b=3376200.000000"), SG_PROJ_FMT_Proj4);
//---------------------------------------------
sLine = (short *)SG_Malloc(NX * sizeof(short));
for(y=0; y<NY && !Stream.is_EOF() && Set_Progress(y, NY); y++)
{
yy = bDown ? NY - 1 - y : y;
Stream.Read(sLine, NX, sizeof(short));
if( fName[10] == 'G' || fName[10] == 'H' )
{
for(xa=0; xa<NX; xa++)
{
SG_Swap_Bytes(sLine + xa, sizeof(short));
pGrid->Set_Value(xa, yy, sLine[xa]);
}
}
else
{
for(xa=0, xb=NX/2; xb<NX; xa++, xb++)
{
SG_Swap_Bytes(sLine + xa, sizeof(short));
SG_Swap_Bytes(sLine + xb, sizeof(short));
pGrid->Set_Value(xa, yy, sLine[xb]);
pGrid->Set_Value(xb, yy, sLine[xa]);
}
}
}
//---------------------------------------------
SG_Free(sLine);
Parameters("GRID")->Set_Value(pGrid);
}
}
return( pGrid != NULL );
}
//---------------------------------------------------------
bool CGrid_Table_Import::On_Execute(void)
{
bool bDown;
int x, y, nx, ny;
double dxy, xmin, ymin, zFactor, zNoData;
TSG_Data_Type data_type;
CSG_String FileName, Unit;
CSG_Grid *pGrid;
CSG_Table Table;
CSG_Table_Record *pRecord;
//-----------------------------------------------------
FileName = Parameters("FILE_DATA") ->asString();
dxy = Parameters("DXY") ->asDouble();
xmin = Parameters("XMIN") ->asDouble();
ymin = Parameters("YMIN") ->asDouble();
bDown = Parameters("TOPDOWN") ->asInt() == 1;
Unit = Parameters("UNIT") ->asString();
zFactor = Parameters("ZFACTOR") ->asDouble();
zNoData = Parameters("NODATA") ->asDouble();
switch( Parameters("DATA_TYPE")->asInt() )
{
default: data_type = SG_DATATYPE_Undefined; break; // not handled
case 0: data_type = SG_DATATYPE_Byte; break; // 1 Byte Integer (unsigned)
case 1: data_type = SG_DATATYPE_Char; break; // 1 Byte Integer (signed)
case 2: data_type = SG_DATATYPE_Word; break; // 2 Byte Integer (unsigned)
case 3: data_type = SG_DATATYPE_Short; break; // 2 Byte Integer (signed)
case 4: data_type = SG_DATATYPE_DWord; break; // 4 Byte Integer (unsigned)
case 5: data_type = SG_DATATYPE_Int; break; // 4 Byte Integer (signed)
case 6: data_type = SG_DATATYPE_Float; break; // 4 Byte Floating Point
case 7: data_type = SG_DATATYPE_Double; break; // 8 Byte Floating Point
}
//-----------------------------------------------------
if( Table.Create(FileName) && (nx = Table.Get_Field_Count()) > 0 && (ny = Table.Get_Record_Count()) > 0 )
{
pGrid = SG_Create_Grid(data_type, nx, ny, dxy, xmin, ymin);
for(y=0; y<ny && Set_Progress(y, ny); y++)
{
pRecord = Table.Get_Record(bDown ? ny - 1 - y : y);
for(x=0; x<nx; x++)
{
pGrid->Set_Value(x, y, pRecord->asDouble(x));
}
}
pGrid->Set_Unit (Unit);
pGrid->Set_ZFactor (zFactor);
pGrid->Set_NoData_Value (zNoData);
pGrid->Set_Name (SG_File_Get_Name(FileName, false));
Parameters("GRID")->Set_Value(pGrid);
return( true );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
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 CGrid_Table_Import::On_Execute(void)
{
//-----------------------------------------------------
CSG_Table Table;
if( !Table.Create(Parameters("FILE")->asString()) )
{
Error_Fmt("%s [%s]", _TL("could not open table file"), Parameters("FILE")->asString());
return( false );
}
//-----------------------------------------------------
int nx, ny, nHeadLines = Parameters("HEADLINES")->asInt();
if( (nx = Table.Get_Field_Count()) < 1 || (ny = Table.Get_Record_Count()) < 1 )
{
Error_Fmt("%s [%s]", _TL("no data in table file"), Parameters("FILE")->asString());
return( false );
}
//-----------------------------------------------------
TSG_Data_Type Type;
switch( Parameters("DATA_TYPE")->asInt() )
{
case 0: Type = SG_DATATYPE_Byte ; break; // 1 Byte Integer (unsigned)
case 1: Type = SG_DATATYPE_Char ; break; // 1 Byte Integer (signed)
case 2: Type = SG_DATATYPE_Word ; break; // 2 Byte Integer (unsigned)
case 3: Type = SG_DATATYPE_Short ; break; // 2 Byte Integer (signed)
case 4: Type = SG_DATATYPE_DWord ; break; // 4 Byte Integer (unsigned)
case 5: Type = SG_DATATYPE_Int ; break; // 4 Byte Integer (signed)
default: Type = SG_DATATYPE_Float ; break; // 4 Byte Floating Point
case 7: Type = SG_DATATYPE_Double; break; // 8 Byte Floating Point
}
//-----------------------------------------------------
CSG_Grid *pGrid = SG_Create_Grid(Type, nx, ny,
Parameters("CELLSIZE")->asDouble(),
Parameters("XMIN" )->asDouble(),
Parameters("YMIN" )->asDouble()
);
pGrid->Set_Name (SG_File_Get_Name(Parameters("FILE")->asString(), false));
pGrid->Set_Unit (Parameters("UNIT" )->asString());
pGrid->Set_NoData_Value(Parameters("NODATA" )->asDouble());
pGrid->Set_Scaling (Parameters("ZFACTOR")->asDouble());
Parameters("GRID")->Set_Value(pGrid);
//-----------------------------------------------------
bool bDown = Parameters("TOPDOWN")->asInt() == 1;
for(int y=0; y<ny && Set_Progress(y, ny); y++)
{
CSG_Table_Record *pRecord = Table.Get_Record(y + nHeadLines);
for(int x=0, yy=bDown?ny-1-y:y; x<nx; x++)
{
pGrid->Set_Value(x, yy, pRecord->asDouble(x));
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSurfer_Import::On_Execute(void)
{
int x, y, NX, NY;
short sValue;
long lValue;
float *fLine;
double *dLine, dValue, DX, DY, xMin, yMin;
FILE *Stream;
CSG_String fName;
CSG_Grid *pGrid;
//-----------------------------------------------------
pGrid = NULL;
fName = Parameters("FILE")->asString();
//-----------------------------------------------------
if( fName.Length() > 0 && (Stream = fopen(fName.b_str(), "rb")) != NULL )
{
fread(&lValue, 1, sizeof(long), Stream);
//-------------------------------------------------
// Surfer 7: Binary...
if( !strncmp((char *)&lValue, "DSRB", 4) )
{
fread(&lValue, 1, sizeof(long) , Stream); // SectionSize...
fread(&lValue, 1, sizeof(long) , Stream); // Version
fread(&lValue, 1, sizeof(long) , Stream);
if( lValue == 0x44495247 ) // Grid-Header...
{
fread(&lValue , 1, sizeof(long) , Stream); // SectionSize...
fread(&lValue , 1, sizeof(long) , Stream); // NX...
NY = (int)lValue;
fread(&lValue , 1, sizeof(long) , Stream); // NY...
NX = (int)lValue;
fread(&xMin , 1, sizeof(double) , Stream); // xMin...
fread(&yMin , 1, sizeof(double) , Stream); // yMin...
fread(&DX , 1, sizeof(double) , Stream); // DX...
fread(&DY , 1, sizeof(double) , Stream); // DY...
fread(&dValue , 1, sizeof(double) , Stream); // zMin...
fread(&dValue , 1, sizeof(double) , Stream); // zMax...
fread(&dValue , 1, sizeof(double) , Stream); // Rotation (unused)...
fread(&dValue , 1, sizeof(double) , Stream); // Blank Value...
fread(&lValue , 1, sizeof(long) , Stream); // ???...
if( lValue == 0x41544144 ) // Load Binary Double...
{
fread(&lValue, 1, sizeof(long) , Stream); // SectionSize...
//-------------------------------------
if( !feof(Stream) && (pGrid = SG_Create_Grid(SG_DATATYPE_Double, NX, NY, DX, xMin, yMin)) != NULL )
{
dLine = (double *)SG_Malloc(pGrid->Get_NX() * sizeof(double));
for(y=0; y<pGrid->Get_NY() && !feof(Stream) && Set_Progress(y, pGrid->Get_NY()); y++)
{
fread(dLine, pGrid->Get_NX(), sizeof(double), Stream);
for(x=0; x<pGrid->Get_NX(); x++)
{
pGrid->Set_Value(x, y, dLine[x]);
}
}
SG_Free(dLine);
}
}
}
}
//-------------------------------------------------
// Surfer 6: Binary...
else if( !strncmp((char *)&lValue, "DSBB", 4) )
{
fread(&sValue , 1, sizeof(short) , Stream);
NX = sValue;
fread(&sValue , 1, sizeof(short) , Stream);
NY = sValue;
fread(&xMin , 1, sizeof(double) , Stream);
fread(&dValue , 1, sizeof(double) , Stream); // XMax
DX = (dValue - xMin) / (NX - 1.0);
fread(&yMin , 1, sizeof(double) , Stream);
fread(&dValue , 1, sizeof(double) , Stream); // YMax...
DY = (dValue - yMin) / (NY - 1.0);
fread(&dValue , 1, sizeof(double) , Stream); // ZMin...
fread(&dValue , 1, sizeof(double) , Stream); // ZMax...
//---------------------------------------------
if( !feof(Stream) && (pGrid = SG_Create_Grid(SG_DATATYPE_Float, NX, NY, DX, xMin, yMin)) != NULL )
{
fLine = (float *)SG_Malloc(pGrid->Get_NX() * sizeof(float));
for(y=0; y<pGrid->Get_NY() && !feof(Stream) && Set_Progress(y, pGrid->Get_NY()); y++)
{
fread(fLine, pGrid->Get_NX(), sizeof(float), Stream);
for(x=0; x<pGrid->Get_NX(); x++)
{
pGrid->Set_Value(x, y, fLine[x]);
}
}
SG_Free(fLine);
}
}
//-------------------------------------------------
// Surfer 6: ASCII...
else if( !strncmp((char *)&lValue, "DSAA", 4) )
{
fscanf(Stream, "%d %d" , &NX , &NY);
fscanf(Stream, "%lf %lf", &xMin , &dValue);
DX = (dValue - xMin) / (NX - 1.0);
fscanf(Stream, "%lf %lf", &yMin , &dValue);
DY = (dValue - yMin) / (NY - 1.0);
fscanf(Stream, "%lf %lf", &dValue, &dValue);
//---------------------------------------------
if( !feof(Stream) && (pGrid = SG_Create_Grid(SG_DATATYPE_Float, NX, NY, DX, xMin, yMin)) != NULL )
{
for(y=0; y<pGrid->Get_NY() && !feof(Stream) && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(x=0; x<pGrid->Get_NX(); x++)
{
fscanf(Stream, "%lf", &dValue);
pGrid->Set_Value(x, y, dValue);
}
}
}
}
fclose(Stream);
}
//-----------------------------------------------------
if( pGrid )
{
pGrid->Set_Name(Parameters("FILE")->asString());
pGrid->Set_NoData_Value(Parameters("NODATA")->asInt() == 0 ? NODATAVALUE : Parameters("NODATA_VAL")->asDouble());
Parameters("GRID")->Set_Value(pGrid);
}
return( pGrid != NULL );
}
//---------------------------------------------------------
bool CWRF_Import::Load(const CSG_String &File)
{
//-----------------------------------------------------
// 00001-00600.00001-00600
// 01234567890123456789012
CSG_String Name = SG_File_Get_Name(File, true);
if( Name.Length() != 23 || Name[5] != SG_T('-') || Name[11] != SG_T('.') || Name[17] != SG_T('-') )
{
Error_Set(_TL("invalid geogrid file name"));
return( false );
}
int xOffset = Name.asInt() - 1;
int yOffset = Name.AfterFirst(SG_T('.')).asInt() - 1;
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(File, SG_FILE_R) )
{
Error_Set(_TL("data file could not be openend"));
return( false );
}
//-----------------------------------------------------
TSG_Data_Type Type;
switch( m_Index.m_WORDSIZE )
{
default:
Error_Set(_TL("invalid word size"));
return( false );
case 1: Type = m_Index.m_SIGNED == false ? SG_DATATYPE_Byte : SG_DATATYPE_Char; break;
case 2: Type = m_Index.m_SIGNED == false ? SG_DATATYPE_Word : SG_DATATYPE_Short; break;
case 4: Type = m_Index.m_SIGNED == false ? SG_DATATYPE_DWord : SG_DATATYPE_Int; break;
}
//-----------------------------------------------------
char *pLine, *pValue;
int x, y, nBytes_Line;
nBytes_Line = (m_Index.m_TILE_X + 2 * m_Index.m_TILE_BDR) * m_Index.m_WORDSIZE;
pLine = (char *)SG_Malloc(nBytes_Line);
//-----------------------------------------------------
for(int z=m_Index.m_TILE_Z_START; z<=m_Index.m_TILE_Z_END && !Stream.is_EOF() && Process_Get_Okay(); z++)
{
CSG_Grid *pGrid = SG_Create_Grid(
Type,
m_Index.m_TILE_X + 2 * m_Index.m_TILE_BDR,
m_Index.m_TILE_Y + 2 * m_Index.m_TILE_BDR,
m_Index.m_DX,
m_Index.m_KNOWN_LON + (xOffset - m_Index.m_TILE_BDR) * m_Index.m_DX,
m_Index.m_KNOWN_LAT + (yOffset - m_Index.m_TILE_BDR) * m_Index.m_DY
);
pGrid->Set_Name (CSG_String::Format(SG_T("%s_%02d"), SG_File_Get_Name(File, false).c_str(), z));
pGrid->Set_Description (m_Index.m_DESCRIPTION);
pGrid->Set_Unit (m_Index.m_UNITS);
pGrid->Set_NoData_Value (m_Index.m_MISSING_VALUE);
pGrid->Set_Scaling (m_Index.m_SCALE_FACTOR);
Parameters("GRIDS")->asGridList()->Add_Item(pGrid);
//-------------------------------------------------
for(y=0; y<pGrid->Get_NY() && !Stream.is_EOF() && Set_Progress(y, pGrid->Get_NY()); y++)
{
int yy = m_Index.m_ROW_ORDER == VAL_TOP_BOTTOM ? pGrid->Get_NY() - 1 - y : y;
Stream.Read(pLine, sizeof(char), nBytes_Line);
for(x=0, pValue=pLine; x<pGrid->Get_NX(); x++, pValue+=m_Index.m_WORDSIZE)
{
if( m_Index.m_ENDIAN == VAL_ENDIAN_BIG )
{
SG_Swap_Bytes(pValue, m_Index.m_WORDSIZE);
}
switch( pGrid->Get_Type() )
{
case SG_DATATYPE_Byte: pGrid->Set_Value(x, yy, *(unsigned char *)pValue); break; // 1 Byte Integer (unsigned)
case SG_DATATYPE_Char: pGrid->Set_Value(x, yy, *(signed char *)pValue); break; // 1 Byte Integer (signed)
case SG_DATATYPE_Word: pGrid->Set_Value(x, yy, *(unsigned short *)pValue); break; // 2 Byte Integer (unsigned)
case SG_DATATYPE_Short: pGrid->Set_Value(x, yy, *(signed short *)pValue); break; // 2 Byte Integer (signed)
case SG_DATATYPE_DWord: pGrid->Set_Value(x, yy, *(unsigned int *)pValue); break; // 4 Byte Integer (unsigned)
case SG_DATATYPE_Int: pGrid->Set_Value(x, yy, *(signed int *)pValue); break; // 4 Byte Integer (signed)
}
}
}
}
//-----------------------------------------------------
SG_Free(pLine);
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 CSurfer_Import::On_Execute(void)
{
//-----------------------------------------------------
CSG_String File = Parameters("FILE")->asString();
FILE *Stream = fopen(File.b_str(), "rb");
if( !Stream )
{
Error_Set(_TL("failed to open file"));
return( false );
}
CSG_Grid *pGrid = NULL;
char Id[4]; fread(Id, 1, 4 * sizeof(char), Stream);
//-----------------------------------------------------
if( !strncmp(Id, "DSRB", 4) ) // Surfer 7: Binary...
{
long lValue, nx, ny;
double dValue, dx, dy, xmin, ymin;
fread(&lValue, 1, sizeof(long), Stream); // SectionSize...
fread(&lValue, 1, sizeof(long), Stream); // Version
fread(&lValue, 1, sizeof(long), Stream);
if( lValue == 0x44495247 ) // Grid-Header...
{
fread(&lValue, 1, sizeof(long ), Stream); // SectionSize...
fread(&ny , 1, sizeof(long ), Stream);
fread(&nx , 1, sizeof(long ), Stream);
fread(&xmin , 1, sizeof(double), Stream);
fread(&ymin , 1, sizeof(double), Stream);
fread(&dx , 1, sizeof(double), Stream);
fread(&dy , 1, sizeof(double), Stream);
fread(&dValue, 1, sizeof(double), Stream);
fread(&dValue, 1, sizeof(double), Stream);
fread(&dValue, 1, sizeof(double), Stream); // Rotation (unused)...
fread(&dValue, 1, sizeof(double), Stream); // Blank Value...
fread(&lValue, 1, sizeof(long ), Stream); // ???...
if( lValue == 0x41544144 ) // Load Binary Double...
{
fread(&lValue, 1, sizeof(long), Stream); // SectionSize...
//-----------------------------------------
if( !feof(Stream) && (pGrid = SG_Create_Grid(SG_DATATYPE_Double, nx, ny, dx, xmin, ymin)) != NULL )
{
double *Line = (double *)SG_Malloc(pGrid->Get_NX() * sizeof(double));
for(int y=0; y<pGrid->Get_NY() && !feof(Stream) && Set_Progress(y, pGrid->Get_NY()); y++)
{
fread(Line, pGrid->Get_NX(), sizeof(double), Stream);
for(int x=0; x<pGrid->Get_NX(); x++)
{
pGrid->Set_Value(x, y, Line[x]);
}
}
SG_Free(Line);
}
}
}
}
//-----------------------------------------------------
else if( !strncmp(Id, "DSBB", 4) ) // Surfer 6: Binary...
{
short nx, ny;
double dValue, dx, dy, xmin, ymin;
fread(&nx , 1, sizeof(short ), Stream);
fread(&ny , 1, sizeof(short ), Stream);
fread(&xmin , 1, sizeof(double), Stream);
fread(&dx , 1, sizeof(double), Stream); dx = (dx - xmin) / (nx - 1.0); // XMax
fread(&ymin , 1, sizeof(double), Stream);
fread(&dy , 1, sizeof(double), Stream); dy = (dy - ymin) / (ny - 1.0); // YMax...
fread(&dValue, 1, sizeof(double), Stream); // ZMin...
fread(&dValue, 1, sizeof(double), Stream); // ZMax...
//-------------------------------------------------
if( !feof(Stream) && (pGrid = SG_Create_Grid(SG_DATATYPE_Float, nx, ny, dx, xmin, ymin)) != NULL )
{
float *Line = (float *)SG_Malloc(pGrid->Get_NX() * sizeof(float));
for(int y=0; y<pGrid->Get_NY() && !feof(Stream) && Set_Progress(y, pGrid->Get_NY()); y++)
{
fread(Line, pGrid->Get_NX(), sizeof(float), Stream);
for(int x=0; x<pGrid->Get_NX(); x++)
{
pGrid->Set_Value(x, y, Line[x]);
}
}
SG_Free(Line);
}
}
//-----------------------------------------------------
else if( !strncmp(Id, "DSAA", 4) ) // Surfer 6: ASCII...
{
int nx, ny;
double dx, dy, xmin, ymin, dValue;
fscanf(Stream, "%d %d" , &nx , &ny );
fscanf(Stream, "%lf %lf", &xmin , &dx ); dx = (dx - xmin) / (nx - 1.0);
fscanf(Stream, "%lf %lf", &ymin , &dy ); dy = (dy - ymin) / (ny - 1.0);
fscanf(Stream, "%lf %lf", &dValue, &dValue);
//-------------------------------------------------
if( !feof(Stream) && (pGrid = SG_Create_Grid(SG_DATATYPE_Float, nx, ny, dx, xmin, ymin)) != NULL )
{
for(int y=0; y<pGrid->Get_NY() && !feof(Stream) && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
fscanf(Stream, "%lf", &dValue);
pGrid->Set_Value(x, y, dValue);
}
}
}
}
//-----------------------------------------------------
fclose(Stream);
if( pGrid )
{
pGrid->Set_Name(SG_File_Get_Name(File, false));
pGrid->Set_NoData_Value(Parameters("NODATA")->asInt() == 0 ? NODATAVALUE : Parameters("NODATA_VAL")->asDouble());
Parameters("GRID")->Set_Value(pGrid);
return( true );
}
return( false );
}
//---------------------------------------------------------
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 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 );
}
//---------------------------------------------------------
bool CGrid_Cluster_Analysis::On_Execute(void)
{
if( Parameters("OLDVERSION")->asBool() ) { return( _On_Execute() ); }
//-----------------------------------------------------
bool bNormalize;
int iFeature;
sLong iElement, nElements;
CSG_Cluster_Analysis Analysis;
CSG_Grid *pCluster;
CSG_Parameter_Grid_List *pGrids;
//-----------------------------------------------------
pGrids = Parameters("GRIDS" )->asGridList();
pCluster = Parameters("CLUSTER" )->asGrid();
bNormalize = Parameters("NORMALISE")->asBool();
if( !Analysis.Create(pGrids->Get_Count()) )
{
return( false );
}
//-----------------------------------------------------
pCluster->Set_NoData_Value(0.0);
for(iElement=0, nElements=0; iElement<Get_NCells() && Set_Progress_NCells(iElement); iElement++)
{
bool bNoData = false;
for(iFeature=0; iFeature<pGrids->Get_Count() && !bNoData; iFeature++)
{
if( pGrids->asGrid(iFeature)->is_NoData(iElement) )
{
bNoData = true;
}
}
if( bNoData || !Analysis.Add_Element() )
{
pCluster->Set_Value(iElement, 0);
}
else
{
pCluster->Set_Value(iElement, 1);
for(iFeature=0; iFeature<pGrids->Get_Count(); iFeature++)
{
double d = pGrids->asGrid(iFeature)->asDouble(iElement);
if( bNormalize )
{
d = (d - pGrids->asGrid(iFeature)->Get_Mean()) / pGrids->asGrid(iFeature)->Get_StdDev();
}
Analysis.Set_Feature(nElements, iFeature, d);
}
nElements++;
}
}
if( nElements <= 1 )
{
return( false );
}
//-----------------------------------------------------
bool bResult = Analysis.Execute(
Parameters("METHOD" )->asInt(),
Parameters("NCLUSTER")->asInt(),
Parameters("MAXITER" )->asInt()
);
for(iElement=0, nElements=0; iElement<Get_NCells(); iElement++)
{
Set_Progress_NCells(iElement);
if( !pCluster->is_NoData(iElement) )
{
pCluster->Set_Value(iElement, 1 + Analysis.Get_Cluster(nElements++));
}
}
Save_Statistics(pGrids, bNormalize, Analysis);
Save_LUT(pCluster);
return( bResult );
}
