//---------------------------------------------------------
bool Copy_RGBGrid_SAGA_to_VIGRA (CSG_Grid &Grid, BRGBImage &Image, bool bCreate)
{
if( bCreate )
{
Image.resize(Grid.Get_NX(), Grid.Get_NY());
}
if( Grid.Get_NX() != Image.width() || Grid.Get_NY() != Image.height() )
{
return( false );
}
for(int y=0; y<Grid.Get_NY() && SG_UI_Process_Set_Progress(y, Grid.Get_NY()); y++)
{
for(int x=0; x<Grid.Get_NX(); x++)
{
RGBValue<unsigned char> rgb(SG_GET_R(Grid.asInt(x, y)), SG_GET_G(Grid.asInt(x, y)), SG_GET_B(Grid.asInt(x, y)));
Image(x, y) = rgb;
}
}
SG_UI_Process_Set_Progress(0.0, 1.0);
return( true );
}
//---------------------------------------------------------
bool CDVWK_SoilMoisture::On_Execute(void)
{
int Day, x, y, i, LandUseID;
CSG_Grid *pGrid;
//-----------------------------------------------------
if( pClimate->Get_Record_Count() > 0 )
{
pFK_mm = Parameters("STA_FC") ->asGrid();
FK_mm_Def = Parameters("STA_FC_DEF") ->asDouble();
pPWP_mm = Parameters("STA_PWP") ->asGrid();
PWP_mm_Def = Parameters("STA_PWP_DEF") ->asDouble();
pWi_mm = Parameters("DYN_W") ->asGrid();
DataObject_Set_Colors(pWi_mm, 100, SG_COLORS_YELLOW_BLUE);
//-------------------------------------------------
pLandUse = SG_Create_Grid(pWi_mm, pCropCoeff->Get_Record_Count() < 127 ? SG_DATATYPE_Char : SG_DATATYPE_Int);
pLandUse->Assign(Parameters("LANDUSE_DEF")->asInt());
if( (pGrid = Parameters("LANDUSE")->asGrid()) != NULL )
{
for(y=0; y<Get_NY(); y++)
{
for(x=0; x<Get_NX(); x++)
{
LandUseID = pGrid->asInt(x, y);
for(i=0; i<pCropCoeff->Get_Record_Count(); i++)
{
if( LandUseID == pCropCoeff->Get_Record(i)->asInt(0) )
{
pLandUse->Set_Value(x, y, i);
break;
}
}
}
}
}
//-------------------------------------------------
DataObject_Update(pWi_mm, 0, pFK_mm ? pFK_mm->Get_ZMax() : FK_mm_Def, true);
for(Day=0; Day<365 && Set_Progress(Day, 365); Day++)
{
Step_Day(Day);
DataObject_Update(pWi_mm, true);
}
//-------------------------------------------------
delete(pLandUse);
return( true );
}
return( false );
}
//---------------------------------------------------------
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 CGrid_Import::On_Execute(void)
{
bool bTransform;
int x, y, yy, Method;
double ax, ay, dx, dy, rx, ry, xMin, yMin, Cellsize;
CSG_Colors Colors;
CSG_String fImage, fWorld, Name;
CSG_Grid *pImage;
CSG_File Stream;
wxImage Image;
wxImageHistogram Histogram;
//-----------------------------------------------------
fImage = Parameters("FILE") ->asString();
Method = Parameters("METHOD") ->asInt();
Name = SG_File_Get_Name(fImage, false);
//-----------------------------------------------------
wxImageHandler *pImgHandler = NULL;
if( !SG_UI_Get_Window_Main() )
{
CSG_String fName = SG_File_Get_Name(fImage, true);
if( SG_File_Cmp_Extension(fName, SG_T("jpg")) )
pImgHandler = new wxJPEGHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("pcx")) )
pImgHandler = new wxPCXHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("tif")) )
pImgHandler = new wxTIFFHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("gif")) )
pImgHandler = new wxGIFHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("pnm")) )
pImgHandler = new wxPNMHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("xpm")) )
pImgHandler = new wxXPMHandler;
#ifdef _SAGA_MSW
else if( SG_File_Cmp_Extension(fName, SG_T("bmp")) )
pImgHandler = new wxBMPHandler;
#endif
else // if( SG_File_Cmp_Extension(fName, SG_T("png")) )
pImgHandler = new wxPNGHandler;
wxImage::AddHandler(pImgHandler);
}
if( !Image.LoadFile(fImage.c_str()) )
{
return( false );
}
//-----------------------------------------------------
if( SG_File_Cmp_Extension(fImage, SG_T("bmp")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("bpw"));
}
else if( SG_File_Cmp_Extension(fImage, SG_T("jpg")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("jgw"));
}
else if( SG_File_Cmp_Extension(fImage, SG_T("png")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("pgw"));
}
else if( SG_File_Cmp_Extension(fImage, SG_T("tif")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("tfw"));
}
else
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("world"));
}
bTransform = false;
xMin = 0.0;
yMin = 0.0;
Cellsize = 1.0;
if( Stream.Open(fWorld, SG_FILE_R, false) && fscanf(Stream.Get_Stream(), "%lf %lf %lf %lf %lf %lf ", &dx, &ry, &rx, &dy, &ax, &ay) == 6 )
{
if( dx != -dy || rx != 0.0 || ry != 0.0 )
{
bTransform = true;
}
else
{
xMin = ax;
yMin = ay + dy * (Image.GetHeight() - 1);
Cellsize = dx;
}
}
//-----------------------------------------------------
// color look-up table...
if( Method == 0 && (yy = Image.ComputeHistogram(Histogram)) <= 256 )
{
Colors.Set_Count(yy);
for(wxImageHistogram::iterator i=Histogram.begin(); i!=Histogram.end(); ++i)
{
Colors.Set_Color(i->second.index, SG_GET_R(i->first), SG_GET_G(i->first), SG_GET_B(i->first));
}
pImage = SG_Create_Grid(yy <= 2 ? SG_DATATYPE_Bit : SG_DATATYPE_Byte, Image.GetWidth(), Image.GetHeight(), Cellsize, xMin, yMin);
for(y=0; y<pImage->Get_NY() && Set_Progress(y, pImage->Get_NY()); y++)
{
yy = bTransform ? y : pImage->Get_NY() - 1 - y;
for(x=0; x<pImage->Get_NX(); x++)
{
pImage->Set_Value(x, y, Histogram[SG_GET_RGB(Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy))].index);
}
}
if( bTransform )
{
Set_Transformation(&pImage, ax, ay, dx, dy, rx, ry);
}
pImage->Set_Name(Name);
pImage->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
Parameters("OUT_GRID")->Set_Value(pImage);
DataObject_Set_Colors(pImage, Colors);
DataObject_Update(pImage, 0, Colors.Get_Count() - 1);
}
//-----------------------------------------------------
else // true color...
{
pImage = SG_Create_Grid(SG_DATATYPE_Int, Image.GetWidth(), Image.GetHeight(), Cellsize, xMin, yMin);
pImage ->Set_Name(Name);
for(y=0; y<pImage->Get_NY() && Set_Progress(y, pImage->Get_NY()); y++)
{
yy = bTransform ? y : pImage->Get_NY() - 1 - y;
for(x=0; x<pImage->Get_NX(); x++)
{
pImage->Set_Value(x, y, SG_GET_RGB(Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy)));
}
}
if( bTransform )
{
Set_Transformation(&pImage, ax, ay, dx, dy, rx, ry);
}
//-------------------------------------------------
if( Method != 1 ) // true color...
{
pImage->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pImage->Set_Name(Name);
pImage->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
Parameters("OUT_GRID")->Set_Value(pImage);
DataObject_Set_Colors(pImage, 100, SG_COLORS_BLACK_WHITE);
DataObject_Set_Parameter(pImage, "COLORS_TYPE", 6); // Color Classification Type: RGB
}
//-------------------------------------------------
else // split channels...
{
CSG_Grid *pR, *pG, *pB;
pR = SG_Create_Grid(pImage->Get_System(), SG_DATATYPE_Byte);
pG = SG_Create_Grid(pImage->Get_System(), SG_DATATYPE_Byte);
pB = SG_Create_Grid(pImage->Get_System(), SG_DATATYPE_Byte);
for(y=0; y<pImage->Get_NY() && Set_Progress(y, pImage->Get_NY()); y++)
{
for(x=0; x<pImage->Get_NX(); x++)
{
pR->Set_Value(x, y, SG_GET_R(pImage->asInt(x, y)));
pG->Set_Value(x, y, SG_GET_G(pImage->asInt(x, y)));
pB->Set_Value(x, y, SG_GET_B(pImage->asInt(x, y)));
}
}
pR->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pG->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pB->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pR->Set_Name(CSG_String::Format(SG_T("%s [R]"), Name.c_str()));
pG->Set_Name(CSG_String::Format(SG_T("%s [G]"), Name.c_str()));
pB->Set_Name(CSG_String::Format(SG_T("%s [B]"), Name.c_str()));
pR->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
pG->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
pB->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
Parameters("OUT_RED") ->Set_Value(pR);
Parameters("OUT_GREEN") ->Set_Value(pG);
Parameters("OUT_BLUE") ->Set_Value(pB);
DataObject_Set_Colors(pR, 100, SG_COLORS_BLACK_RED);
DataObject_Set_Colors(pG, 100, SG_COLORS_BLACK_GREEN);
DataObject_Set_Colors(pB, 100, SG_COLORS_BLACK_BLUE);
}
}
//-----------------------------------------------------
if( !SG_UI_Get_Window_Main() && pImgHandler != NULL)
{
wxImage::RemoveHandler(pImgHandler->GetName());
}
//-----------------------------------------------------
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 CWRF_Export::Save(const CSG_String &Directory, CSG_Parameter_Grid_List *pGrids)
{
//-----------------------------------------------------
// 00001-00600.00001-00600
// 01234567890123456789012
int xOffset = m_Index.m_TILE_BDR + (int)(0.5 + (Get_XMin() - m_Index.m_KNOWN_LON) / Get_Cellsize());
int yOffset = m_Index.m_TILE_BDR + (int)(0.5 + (Get_YMin() - m_Index.m_KNOWN_LAT) / Get_Cellsize());
CSG_String Name = SG_File_Get_Name(Directory, true);
Name.Printf(SG_T("%05d-%05d.%05d-%05d"), xOffset + 1, xOffset + m_Index.m_TILE_X, yOffset + 1, yOffset + m_Index.m_TILE_Y);
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(SG_File_Make_Path(Directory, Name), SG_FILE_W) )
{
Error_Set(_TL("data file could not be openend"));
return( false );
}
//-----------------------------------------------------
char *pLine, *pValue;
int x, y, nBytes_Line;
nBytes_Line = Get_NX() * m_Index.m_WORDSIZE;
pLine = (char *)SG_Malloc(nBytes_Line);
//-----------------------------------------------------
for(int z=0; z<pGrids->Get_Count() && Process_Get_Okay(); z++)
{
CSG_Grid *pGrid = pGrids->asGrid(z);
//-------------------------------------------------
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;
for(x=0, pValue=pLine; x<pGrid->Get_NX(); x++, pValue+=m_Index.m_WORDSIZE)
{
if( m_Index.m_SIGNED )
{
switch( m_Index.m_WORDSIZE )
{
case 1: *((signed char *)pValue) = (signed char )pGrid->asInt(x, yy); break;
case 2: *((signed short *)pValue) = (signed short )pGrid->asInt(x, yy); break;
case 4: *((signed int *)pValue) = (signed int )pGrid->asInt(x, yy); break;
}
}
else
{
switch( m_Index.m_WORDSIZE )
{
case 1: *((unsigned char *)pValue) = (unsigned char )pGrid->asInt(x, yy); break;
case 2: *((unsigned short *)pValue) = (unsigned short)pGrid->asInt(x, yy); break;
case 4: *((unsigned int *)pValue) = (unsigned int )pGrid->asInt(x, yy); break;
}
}
if( m_Index.m_ENDIAN == VAL_ENDIAN_BIG )
{
SG_Swap_Bytes(pValue, m_Index.m_WORDSIZE);
}
}
Stream.Write(pLine, sizeof(char), nBytes_Line);
}
}
//-----------------------------------------------------
SG_Free(pLine);
return( true );
}