//---------------------------------------------------------
bool CSet_Grid_Georeference::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
double xMin, yMin, size;
switch( Parameters("DEFINITION")->asInt() )
{
case 0: // cellsize and lower left center coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
break;
case 1: // cellsize and lower left corner coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMIN")->asDouble() + size * 0.5;
break;
case 2: // cellsize and upper left center coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMAX")->asDouble() - size * Get_NY();
break;
case 3: // cellsize and upper left corner coordinates
size = Parameters("SIZE")->asDouble();
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMAX")->asDouble() - size * (0.5 + Get_NY());
break;
case 4: // lower left and upper right center coordinates
size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / Get_NX();
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
break;
case 5: // lower left and upper right corner coordinates
size = (Parameters("XMAX")->asDouble() - Parameters("XMIN")->asDouble()) / (Get_NX() + 1);
xMin = Parameters("XMIN")->asDouble() + size * 0.5;
yMin = Parameters("YMIN")->asDouble() + size * 0.5;
break;
}
//-----------------------------------------------------
CSG_Grid_System System;
if( !System.Assign(size, xMin, yMin, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
Parameters("REFERENCED")->asGridList()->Del_Items();
for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pGrid = pGrids->asGrid(i);
CSG_Grid *pReferenced = SG_Create_Grid(System, pGrid->Get_Type());
pReferenced->Set_Name(pGrid->Get_Name());
pReferenced->Set_Unit(pGrid->Get_Unit());
pReferenced->Set_Scaling(pGrid->Get_Scaling(), pGrid->Get_Offset());
pReferenced->Set_NoData_Value_Range(pGrid->Get_NoData_Value(), pGrid->Get_NoData_hiValue());
pReferenced->Get_MetaData () = pGrid->Get_MetaData ();
pReferenced->Get_Projection() = pGrid->Get_Projection();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
pReferenced->Set_Value(x, y, pGrid->asDouble(x, y));
}
}
Parameters("REFERENCED")->asGridList()->Add_Item(pReferenced);
}
//-----------------------------------------------------
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 CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pSources, CSG_Parameter_Grid_List *pTargets, const CSG_Grid_System &Target_System)
{
if( !m_Projector.Set_Inverse(true) || !pTargets || !pSources || pSources->Get_Count() < 1 )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pX, *pY;
if( !Parameters("CREATE_XY")->asBool() )
{
pX = pY = NULL;
}
else
{
Parameters("OUT_X")->Set_Value(pX = SG_Create_Grid(Target_System, SG_DATATYPE_Float));
pX->Assign_NoData();
pX->Set_Name(_TL("X-Coordinate"));
pX->Get_Projection().Create(m_Projector.Get_Target());
Parameters("OUT_Y")->Set_Value(pY = SG_Create_Grid(Target_System, SG_DATATYPE_Float));
pY->Assign_NoData();
pY->Set_Name(_TL("Y-Coordinate"));
pY->Get_Projection().Create(m_Projector.Get_Target());
}
//-----------------------------------------------------
bool bGeogCS_Adjust = m_Projector.Get_Source().Get_Type() == SG_PROJ_TYPE_CS_Geographic && pSources->asGrid(0)->Get_System().Get_XMax() > 180.0;
Set_Target_Area(pSources->asGrid(0)->Get_System(), Target_System);
//-----------------------------------------------------
int i, n = pTargets->Get_Count();
for(i=0; i<pSources->Get_Count(); i++)
{
CSG_Grid *pSource = pSources->asGrid(i);
CSG_Grid *pTarget = SG_Create_Grid(Target_System, m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float);
if( pTarget )
{
pTarget->Set_NoData_Value_Range (pSource->Get_NoData_Value(), pSource->Get_NoData_hiValue());
pTarget->Set_ZFactor (pSource->Get_ZFactor());
pTarget->Set_Name (CSG_String::Format(SG_T("%s"), pSource->Get_Name()));
pTarget->Set_Unit (pSource->Get_Unit());
pTarget->Assign_NoData();
pTarget->Get_Projection().Create(m_Projector.Get_Target());
pTargets->Add_Item(pTarget);
}
}
//-------------------------------------------------
for(int y=0; y<Target_System.Get_NY() && Set_Progress(y, Target_System.Get_NY()); y++)
{
double yTarget = Target_System.Get_YMin() + y * Target_System.Get_Cellsize();
#pragma omp parallel for private(i)
for(int x=0; x<Target_System.Get_NX(); x++)
{
double z, ySource, xSource = Target_System.Get_XMin() + x * Target_System.Get_Cellsize();
if( is_In_Target_Area(x, y) && m_Projector.Get_Projection(xSource, ySource = yTarget) )
{
if( pX ) pX->Set_Value(x, y, xSource);
if( pY ) pY->Set_Value(x, y, ySource);
if( bGeogCS_Adjust && xSource < 0.0 )
{
xSource += 360.0;
}
for(i=0; i<pTargets->Get_Count(); i++)
{
if( pSources->asGrid(i)->Get_Value(xSource, ySource, z, m_Interpolation) )
{
pTargets->asGrid(n + i)->Set_Value(x, y, z);
}
}
}
}
}
//-----------------------------------------------------
m_Target_Area.Destroy();
return( true );
}
//---------------------------------------------------------
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 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 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 );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pSources, CSG_Parameter_Grid_List *pTargets, const CSG_Grid_System &Target_System)
{
if( !m_Projector.Set_Inverse(true) || !pTargets || !pSources || pSources->Get_Count() < 1 )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pX, *pY;
if( (pX = m_Grid_Target.Get_Grid("OUT_X")) != NULL )
{
pX->Assign_NoData();
pX->Set_Name(_TL("X Coordinates"));
pX->Get_Projection().Create(m_Projector.Get_Target());
}
if( (pY = m_Grid_Target.Get_Grid("OUT_Y")) != NULL )
{
pY->Assign_NoData();
pY->Set_Name(_TL("Y Coordinates"));
pY->Get_Projection().Create(m_Projector.Get_Target());
}
//-----------------------------------------------------
bool bGeogCS_Adjust = m_Projector.Get_Source().Get_Type() == SG_PROJ_TYPE_CS_Geographic && pSources->asGrid(0)->Get_System().Get_XMax() > 180.0;
Set_Target_Area(pSources->asGrid(0)->Get_System(), Target_System);
bool bKeepType = m_Resampling == GRID_RESAMPLING_NearestNeighbour || Parameters("KEEP_TYPE")->asBool();
//-----------------------------------------------------
int i, n = pTargets->Get_Count();
for(i=0; i<pSources->Get_Count(); i++)
{
CSG_Grid *pSource = pSources->asGrid(i);
CSG_Grid *pTarget = SG_Create_Grid(Target_System, bKeepType ? pSource->Get_Type() : SG_DATATYPE_Float);
if( pTarget )
{
pTargets->Add_Item(pTarget);
pTarget->Set_NoData_Value_Range (pSource->Get_NoData_Value(), pSource->Get_NoData_hiValue());
pTarget->Set_Scaling (pSource->Get_Scaling(), pSource->Get_Offset());
pTarget->Set_Name (pSource->Get_Name());
pTarget->Set_Unit (pSource->Get_Unit());
pTarget->Get_Projection().Create(m_Projector.Get_Target());
pTarget->Assign_NoData();
CSG_Parameters Parms; if( DataObject_Get_Parameters(pSource, Parms) ) { DataObject_Add(pTarget); DataObject_Set_Parameters(pTarget, Parms); }
}
}
//-------------------------------------------------
for(int y=0; y<Target_System.Get_NY() && Set_Progress(y, Target_System.Get_NY()); y++)
{
double yTarget = Target_System.Get_YMin() + y * Target_System.Get_Cellsize();
// #pragma omp parallel for private(i)
for(int x=0; x<Target_System.Get_NX(); x++)
{
double z, ySource, xSource = Target_System.Get_XMin() + x * Target_System.Get_Cellsize();
if( is_In_Target_Area(x, y) && m_Projector.Get_Projection(xSource, ySource = yTarget) )
{
if( bGeogCS_Adjust )
{
if( xSource < 0.0 )
{
xSource += 360.0;
}
else if( xSource >= 360.0 )
{
xSource -= 360.0;
}
}
if( pX ) pX->Set_Value(x, y, xSource);
if( pY ) pY->Set_Value(x, y, ySource);
for(i=0; i<pSources->Get_Count(); i++)
{
if( pSources->asGrid(i)->Get_Value(xSource, ySource, z, m_Resampling, false, true) )
{
pTargets->asGrid(n + i)->Set_Value(x, y, z);
}
}
}
}
}
//-----------------------------------------------------
m_Target_Area.Destroy();
return( true );
}