//---------------------------------------------------------
bool C_Kriging_Base::_Get_Grid(void)
{
CSG_Shapes *pShapes = Parameters("SHAPES")->asShapes();
m_pGrid = NULL;
m_pVariance = NULL;
//-------------------------------------------------
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( Dlg_Parameters("USER") )
{
m_pGrid = _Get_Grid(pShapes->Get_Extent());
}
break;
case 1: // grid system...
if( Dlg_Parameters("SYSTEM") )
{
m_pGrid = SG_Create_Grid(*Get_Parameters("SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), SG_DATATYPE_Float);
}
break;
case 2: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = Get_Parameters("GRID")->Get_Parameter("GRID") ->asGrid();
m_pVariance = Get_Parameters("GRID")->Get_Parameter("VARIANCE") ->asGrid();
}
break;
}
//-------------------------------------------------
if( m_pGrid )
{
if( !m_pVariance && Parameters("BVARIANCE")->asBool() )
{
m_pVariance = SG_Create_Grid(m_pGrid, SG_DATATYPE_Float);
}
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s (%s)"), pShapes->Get_Name(), Get_Name()));
Parameters("GRID")->Set_Value(m_pGrid);
if( m_pVariance )
{
m_pVariance->Set_Name(CSG_String::Format(SG_T("%s (%s - %s)"), pShapes->Get_Name(), Get_Name(), _TL("Variance")));
Parameters("VARIANCE")->Set_Value(m_pVariance);
}
if( Parameters("TARGET")->asInt() == 2 )
{
Get_Parameters("GRID")->Get_Parameter("VARIANCE")->Set_Value(m_pVariance);
}
}
//-----------------------------------------------------
return( m_pGrid != NULL );
}
bool CCreateChartLayer::GetExtraParameters(){
int i;
CSG_Shapes *pInput;
CSG_Parameter *pParam;
CSG_String sName;
bool bIsValidSelection = false;
pInput = Parameters("INPUT")->asShapes();
m_pExtraParameters->Create(this, _TL("Fields for diagram"), _TL(""), SG_T("EXTRA"));
m_bIncludeParam = new bool [pInput->Get_Field_Count() ];
for (i = 0; i < pInput->Get_Field_Count(); i++)
{
switch( pInput->Get_Field_Type(i) )
{
default:
break;
case SG_DATATYPE_Byte:
case SG_DATATYPE_Char:
case SG_DATATYPE_Word:
case SG_DATATYPE_Short:
case SG_DATATYPE_DWord:
case SG_DATATYPE_Int:
case SG_DATATYPE_ULong:
case SG_DATATYPE_Long:
case SG_DATATYPE_Float:
case SG_DATATYPE_Double: // is numeric field
m_pExtraParameters->Add_Value(
NULL, SG_Get_String(i,0).c_str(), pInput->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false
);
break;
}
}//for
if(Dlg_Parameters("EXTRA")){
for (i = 0; i < pInput->Get_Field_Count(); i++){
sName = SG_Get_String(i,0);
if (pParam = Get_Parameters("EXTRA")->Get_Parameter(sName.c_str())){
m_bIncludeParam[i] = pParam->asBool();
bIsValidSelection = true;
}//try
else{
m_bIncludeParam[i] = false;
}//else
}//for
m_pExtraParameters->Destroy();
return bIsValidSelection;
}//if
m_pExtraParameters->Destroy();
return false;
}//method
//---------------------------------------------------------
bool CShapes_Cut_Interactive::Get_Extent(CSG_Rect &r)
{
CSG_Parameters *pParameters = Get_Parameters("CUT");
pParameters->Get_Parameter("AX")->Set_Value(r.Get_XMin());
pParameters->Get_Parameter("AY")->Set_Value(r.Get_YMin());
pParameters->Get_Parameter("BX")->Set_Value(r.Get_XMax());
pParameters->Get_Parameter("BY")->Set_Value(r.Get_YMax());
pParameters->Get_Parameter("DX")->Set_Value(r.Get_XRange());
pParameters->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
pParameters->Get_Parameter("AX")->asDouble(),
pParameters->Get_Parameter("AY")->asDouble(),
pParameters->Get_Parameter("BX")->asDouble(),
pParameters->Get_Parameter("BY")->asDouble()
);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGEOTRANS_Grid::On_Execute_Conversion(void)
{
int Interpolation;
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
//-----------------------------------------------------
pSource = Parameters("SOURCE" )->asGrid();
Interpolation = Parameters("INTERPOLATION")->asInt();
Type = Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
//-----------------------------------------------------
if( Get_Target_Extent(pSource, Extent, true) )
{
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, pSource->Get_NY());
}
if( Dlg_Parameters("TARGET") && (pGrid = m_Grid_Target.Get_Grid(Type)) != NULL )
{
return( Set_Grid(pSource, pGrid, Interpolation) );
}
return( false );
}
//---------------------------------------------------------
bool CGEOTRANS_Grid::On_Execute_Conversion(void)
{
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear ; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline ; break;
case 3: Resampling = GRID_RESAMPLING_BSpline ; break;
}
//-----------------------------------------------------
pSource = Parameters("SOURCE")->asGrid();
Type = Resampling == GRID_RESAMPLING_NearestNeighbour ? pSource->Get_Type() : SG_DATATYPE_Float;
//-----------------------------------------------------
if( Get_Target_Extent(pSource, Extent, true) )
{
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, pSource->Get_NY());
}
if( Dlg_Parameters("TARGET") && (pGrid = m_Grid_Target.Get_Grid(Type)) != NULL )
{
return( Set_Grid(pSource, pGrid, Resampling) );
}
return( false );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pGrids)
{
if( pGrids->Get_Count() > 0 && m_Projector.Set_Source(pGrids->asGrid(0)->Get_Projection()) )
{
CSG_Grid_System System;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create user defined grid system...
if( Get_Target_System(pGrids->asGrid(0)->Get_System(), true) && m_Grid_Target.Get_System_User(System) )
{
return( Transform(pGrids, Parameters("TARGET")->asGridList(), System) );
}
break;
case 1: // select existing grid system...
if( Dlg_Parameters("GET_SYSTEM") && m_Grid_Target.Get_System(System) )
{
return( Transform(pGrids, Parameters("TARGET")->asGridList(), System) );
}
break;
case 2: // points as target...
if( Dlg_Parameters("POINTS") )
{
CSG_Shapes *pPoints = Get_Parameters("POINTS")->Get_Parameter("POINTS")->asShapes();
if( pPoints == DATAOBJECT_NOTSET || pPoints == DATAOBJECT_CREATE )
{
Get_Parameters("POINTS")->Get_Parameter("POINTS")->Set_Value(pPoints = SG_Create_Shapes());
}
return( Transform(pGrids, pPoints) );
}
break;
}
}
return( false );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Transform(CSG_Grid *pGrid)
{
if( pGrid->Get_Projection().is_Okay() && m_Projector.Set_Source(pGrid->Get_Projection()) )
{
TSG_Data_Type Type = m_Interpolation == 0 ? pGrid->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create user defined grid...
if( Get_Target_System(pGrid->Get_System(), true) )
{
return( Transform(pGrid, m_Grid_Target.Get_User(Type)) );
}
break;
case 1: // select existing grid system...
if( Dlg_Parameters("GET_GRID") )
{
return( Transform(pGrid, m_Grid_Target.Get_Grid(Type)) );
}
break;
case 2: // points as target...
if( Dlg_Parameters("POINTS") )
{
CSG_Shapes *pPoints = Get_Parameters("POINTS")->Get_Parameter("POINTS")->asShapes();
if( pPoints == DATAOBJECT_NOTSET || pPoints == DATAOBJECT_CREATE )
{
Get_Parameters("POINTS")->Get_Parameter("POINTS")->Set_Value(pPoints = SG_Create_Shapes(SHAPE_TYPE_Point));
}
return( Transform(pGrid, pPoints) );
}
break;
}
}
return( false );
}
//---------------------------------------------------------
bool CCollect_Points::On_Execute_Position(CSG_Point ptWorld, TSG_Module_Interactive_Mode Mode)
{
if( Mode == MODULE_INTERACTIVE_LUP )
{
TSG_Point ptTarget;
if( m_Engine.Get_Converted(ptTarget = ptWorld) )
{
Get_Parameters("REFERENCE")->Get_Parameter("X")->Set_Value(ptTarget.x);
Get_Parameters("REFERENCE")->Get_Parameter("Y")->Set_Value(ptTarget.y);
}
if( Dlg_Parameters("REFERENCE") )
{
int Method = Parameters("METHOD")->asInt();
int Order = Parameters("ORDER" )->asInt();
CSG_Shape *pPoint = m_pPoints->Add_Shape();
pPoint->Add_Point(ptWorld);
pPoint->Set_Value(0, ptWorld.Get_X());
pPoint->Set_Value(1, ptWorld.Get_Y());
pPoint->Set_Value(2, ptTarget.x = Get_Parameters("REFERENCE")->Get_Parameter("X")->asDouble());
pPoint->Set_Value(3, ptTarget.y = Get_Parameters("REFERENCE")->Get_Parameter("Y")->asDouble());
if( m_Engine.Add_Reference(ptWorld, ptTarget) && m_Engine.Evaluate(Method, Order) && m_pPoints->Get_Count() == m_Engine.Get_Reference_Count() )
{
for(int i=0; i<m_pPoints->Get_Count(); i++)
{
m_pPoints->Get_Shape(i)->Set_Value(4, m_Engine.Get_Reference_Residual(i));
}
}
DataObject_Update(m_pPoints);
}
}
return( true );
}
//---------------------------------------------------------
bool CKriging_Base::_Initialise_Grids(void)
{
m_pGrid = NULL;
m_pVariance = NULL;
//-----------------------------------------------------
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
if( Get_Parameters("USER")->Get_Parameter("BVARIANCE")->asBool() )
{
m_pVariance = m_Grid_Target.Get_User(SG_T("VARIANCE"));
}
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
m_pVariance = m_Grid_Target.Get_Grid(SG_T("VARIANCE"));
}
break;
}
if( !m_pGrid )
{
return( false );
}
//-----------------------------------------------------
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("ZFIELD")->asString(), Get_Name().c_str()));
if( m_pVariance )
{
m_pVariance->Set_Name(CSG_String::Format(SG_T("%s [%s %s]"), Parameters("ZFIELD")->asString(), Get_Name().c_str(), m_bStdDev ? _TL("Standard Deviation") : _TL("Variance")));
}
return( true );
}
//---------------------------------------------------------
CSG_Grid * C_Kriging_Base::_Get_Grid(TSG_Rect Extent)
{
CSG_Parameters *P = Get_Parameters("USER");
if( !P->Get_Parameter("FIT_EXTENT")->asBool() )
{
Extent.xMin = P->Get_Parameter("X_EXTENT")->asRange()->Get_LoVal();
Extent.yMin = P->Get_Parameter("Y_EXTENT")->asRange()->Get_LoVal();
Extent.xMax = P->Get_Parameter("X_EXTENT")->asRange()->Get_HiVal();
Extent.yMax = P->Get_Parameter("Y_EXTENT")->asRange()->Get_HiVal();
}
double d = P->Get_Parameter("CELL_SIZE")->asDouble();
int nx = 1 + (int)((Extent.xMax - Extent.xMin) / d);
int ny = 1 + (int)((Extent.yMax - Extent.yMin) / d);
return( nx > 1 && ny > 1 ? SG_Create_Grid(SG_DATATYPE_Float, nx, ny, d, Extent.xMin, Extent.yMin) : NULL );
}
//---------------------------------------------------------
bool CGW_Multi_Regression::Get_Predictors(void)
{
int i;
CSG_Shapes *pPoints = Parameters("POINTS") ->asShapes();
CSG_Parameters *pAttributes = Parameters("PREDICTORS") ->asParameters();
m_nPredictors = 0;
m_iPredictor = new int[pPoints->Get_Field_Count()];
for(i=0; i<pAttributes->Get_Count(); i++)
{
if( pAttributes->Get_Parameter(i)->asBool() )
{
m_iPredictor[m_nPredictors++] = CSG_String(pAttributes->Get_Parameter(i)->Get_Identifier()).asInt();
}
}
CSG_Parameters *pGrids = Get_Parameters("GRID"), Tmp;
Tmp.Assign(pGrids);
pGrids->Create(this, Tmp.Get_Name(), Tmp.Get_Description(), Tmp.Get_Identifier(), false);
m_Grid_Target.Add_Grid_Parameter(SG_T("QUALITY") , _TL("Quality") , false);
m_Grid_Target.Add_Grid_Parameter(SG_T("INTERCEPT") , _TL("Intercept"), false);
pGrids->Get_Parameter("QUALITY")->Get_Parent()->asGrid_System()->Assign(*Tmp("QUALITY")->Get_Parent()->asGrid_System());
pGrids->Get_Parameter("QUALITY") ->Set_Value(Tmp("QUALITY") ->asGrid());
pGrids->Get_Parameter("INTERCEPT")->Set_Value(Tmp("INTERCEPT")->asGrid());
for(i=0; i<m_nPredictors; i++)
{
m_Grid_Target.Add_Grid_Parameter(SG_Get_String(i, 0),
CSG_String::Format(SG_T("%s [%s]"), _TL("Slope"), pPoints->Get_Field_Name(m_iPredictor[i])), false
);
if( Tmp(SG_Get_String(i, 0)) )
{
pGrids->Get_Parameter(SG_Get_String(i, 0))->Set_Value(Tmp(SG_Get_String(i, 0))->asGrid());
}
}
return( m_nPredictors > 0 );
}
//---------------------------------------------------------
bool CCollect_Points::On_Execute(void)
{
m_Engine.Destroy();
m_pPoints = Parameters("REF_SOURCE")->asShapes();
Get_Parameters("REFERENCE")->Restore_Defaults();
if( !is_Compatible(m_pPoints) || Parameters("REFRESH")->asBool() )
{
m_pPoints->Create(SHAPE_TYPE_Point, _TL("Reference Points (Origin)"));
m_pPoints->Add_Field("X_SRC", SG_DATATYPE_Double);
m_pPoints->Add_Field("Y_SRC", SG_DATATYPE_Double);
m_pPoints->Add_Field("X_MAP", SG_DATATYPE_Double);
m_pPoints->Add_Field("Y_MAP", SG_DATATYPE_Double);
m_pPoints->Add_Field("RESID", SG_DATATYPE_Double);
}
else
{
for(int i=0; i<m_pPoints->Get_Count(); i++)
{
CSG_Shape *pPoint = m_pPoints->Get_Shape(i);
m_Engine.Add_Reference(pPoint->Get_Point(0), CSG_Point(
pPoint->asDouble(2),
pPoint->asDouble(3)
));
}
int Method = Parameters("METHOD")->asInt();
int Order = Parameters("ORDER" )->asInt();
m_Engine.Evaluate(Method, Order);
}
return( true );
}
//---------------------------------------------------------
FILE * CSRTM30_Import::Tile_Open(const SG_Char *sTile)
{
const SG_Char *sPath;
FILE *Stream;
CSG_String fName;
CSG_Parameters *pParameters;
fName = sTile;
if( (Stream = fopen(fName.b_str(), "rb")) == NULL )
{
pParameters = Get_Parameters("TILE");
pParameters->Get_Parameter("INFO")->Set_Value(sTile);
if( Dlg_Parameters(pParameters, _TL("Locate STRM30 Data File")) && (sPath = pParameters->Get_Parameter("PATH")->asString()) != NULL )
{
fName = sPath;
Stream = fopen(fName.b_str(), "rb");
}
}
return( Stream );
}
//---------------------------------------------------------
bool CPolygonStatisticsFromPoints::On_Execute(void)
{
int i, j, n, Offset, *bAttribute;
CSG_Simple_Statistics *Statistics;
CSG_Parameters *pParameters;
CSG_Shapes *pPolygons, *pPoints;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
pPolygons = Parameters("POLYGONS") ->asShapes();
if( pPolygons->Get_Count() <= 0 || pPoints->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
pParameters = Get_Parameters("ATTRIBUTES");
pParameters->Del_Parameters();
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
if( SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(i)) )
{
CSG_Parameter *pNode = pParameters->Add_Node(NULL, CSG_String::Format(SG_T("%d"), i), pPoints->Get_Field_Name(i), _TL(""));
for(j=0; j<STAT_Count; j++)
{
pParameters->Add_Value(pNode,
CSG_String::Format(SG_T("%d|%d"), i, j),
CSG_String::Format(SG_T("[%s]"), STAT_Name[j].c_str()),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
}
}
if( !Dlg_Parameters("ATTRIBUTES") )
{
return( false );
}
//-----------------------------------------------------
if( Parameters("STATISTICS")->asShapes() == NULL )
{
Parameters("STATISTICS")->Set_Value(pPolygons);
}
else if( pPolygons != Parameters("STATISTICS")->asShapes() )
{
Parameters("STATISTICS")->asShapes()->Assign(pPolygons);
pPolygons = Parameters("STATISTICS")->asShapes();
}
//-----------------------------------------------------
bAttribute = new int[pPoints->Get_Field_Count()];
Offset = pPolygons->Get_Field_Count();
for(i=0, n=0; i<pPoints->Get_Field_Count(); i++)
{
bAttribute[i] = 0;
if( SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(i)) )
{
for(j=0; j<STAT_Count; j++)
{
CSG_Parameter *pParameter = pParameters->Get_Parameter(CSG_String::Format(SG_T("%d|%d"), i, j));
if( pParameter && pParameter->asBool() )
{
bAttribute[i] |= STAT_Flag[j];
pPolygons->Add_Field(CSG_String::Format(SG_T("%s_%s"), pPoints->Get_Field_Name(i), STAT_Name[j].c_str()), SG_DATATYPE_Double);
n++;
}
}
}
}
if( n == 0 )
{
delete[](bAttribute);
return( false );
}
//-----------------------------------------------------
Statistics = new CSG_Simple_Statistics[pPoints->Get_Field_Count()];
for(int iPolygon=0; iPolygon<pPolygons->Get_Count() && Set_Progress(iPolygon, pPolygons->Get_Count()); iPolygon++)
{
CSG_Shape_Polygon *pPolygon = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iPolygon);
//-------------------------------------------------
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
Statistics[i].Invalidate();
}
//-------------------------------------------------
for(int iPoint=0; iPoint<pPoints->Get_Count() && Process_Get_Okay(); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
if( pPolygon->is_Containing(pPoint->Get_Point(0)) )
{
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
if( bAttribute[i] )
{
Statistics[i].Add_Value(pPoint->asDouble(i));
}
}
}
}
//-------------------------------------------------
for(i=0, n=Offset; i<pPoints->Get_Field_Count(); i++)
{
if( bAttribute[i] )
{
if( Statistics[i].Get_Count() > 0 )
{
if( bAttribute[i] & STAT_Flag[STAT_Sum] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Sum()); }
if( bAttribute[i] & STAT_Flag[STAT_Avg] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Mean()); }
if( bAttribute[i] & STAT_Flag[STAT_Var] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Variance()); }
if( bAttribute[i] & STAT_Flag[STAT_Dev] ) { pPolygon->Set_Value(n++, Statistics[i].Get_StdDev()); }
if( bAttribute[i] & STAT_Flag[STAT_Min] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Minimum()); }
if( bAttribute[i] & STAT_Flag[STAT_Max] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Maximum()); }
if( bAttribute[i] & STAT_Flag[STAT_Num] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Count()); }
}
else
{
if( bAttribute[i] & STAT_Flag[STAT_Sum] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Avg] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Var] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Dev] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Min] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Max] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Num] ) { pPolygon->Set_NoData(n++); }
}
}
}
}
//-----------------------------------------------------
delete[](Statistics);
delete[](bAttribute);
DataObject_Update(pPolygons);
return( true );
}
//---------------------------------------------------------
bool CDirect_Georeferencing::On_Execute(void)
{
//-----------------------------------------------------
if( !m_Georeferencer.Set_Transformation(Parameters, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pDEM = Parameters("DEM" )->asGrid();
double zRef = Parameters("ZREF" )->asDouble();
bool bFlip = Parameters("ROW_ORDER")->asInt() == 1;
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
//-----------------------------------------------------
TSG_Point p[4];
p[0] = m_Georeferencer.Image_to_World( 0, 0, zRef);
p[1] = m_Georeferencer.Image_to_World(Get_NX(), 0, zRef);
p[2] = m_Georeferencer.Image_to_World(Get_NX(), Get_NY(), zRef);
p[3] = m_Georeferencer.Image_to_World( 0, Get_NY(), zRef);
CSG_Rect r(p[0], p[1]); r.Union(p[2]); r.Union(p[3]);
//-----------------------------------------------------
CSG_Shapes *pShapes = Parameters("EXTENT")->asShapes();
if( pShapes )
{
pShapes->Create(SHAPE_TYPE_Polygon, _TL("Extent"));
pShapes->Add_Field(_TL("OID"), SG_DATATYPE_Int);
CSG_Shape *pExtent = pShapes->Add_Shape();
pExtent->Add_Point(p[0]);
pExtent->Add_Point(p[1]);
pExtent->Add_Point(p[2]);
pExtent->Add_Point(p[3]);
}
//-----------------------------------------------------
double Cellsize = SG_Get_Distance(p[0], p[1]) / Get_NX();
CSG_Grid_System System(Cellsize, r);
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), r, Get_NX());
if( !Dlg_Parameters("TARGET") )
{
return( false );
}
System = m_Grid_Target.Get_System();
if( !System.is_Valid() )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList();
CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList();
pOutput->Del_Items();
if( pInput->Get_Count() <= 0 )
{
return( false );
}
else
{
TSG_Data_Type Type;
switch( Parameters("DATA_TYPE")->asInt() )
{
case 0: Type = SG_DATATYPE_Byte; break;
case 1: Type = SG_DATATYPE_Char; break;
case 2: Type = SG_DATATYPE_Word; break;
case 3: Type = SG_DATATYPE_Short; break;
case 4: Type = SG_DATATYPE_DWord; break;
case 5: Type = SG_DATATYPE_Int; break;
case 6: Type = SG_DATATYPE_Float; break;
case 7: Type = SG_DATATYPE_Double; break;
default: Type = SG_DATATYPE_Undefined; break;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
CSG_Grid *pGrid = SG_Create_Grid(System, Type != SG_DATATYPE_Undefined ? Type : pInput->asGrid(i)->Get_Type());
if( !pGrid || !pGrid->is_Valid() )
{
if( pGrid )
{
delete(pGrid);
}
return( false );
}
pOutput->Add_Item(pGrid);
pGrid->Set_Name(pInput->asGrid(i)->Get_Name());
}
}
//-----------------------------------------------------
for(int y=0; y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++)
{
double py = System.Get_YMin() + y * System.Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<System.Get_NX(); x++)
{
double pz, px = System.Get_XMin() + x * System.Get_Cellsize();
if( !pDEM || !pDEM->Get_Value(px, py, pz) )
{
pz = zRef;
}
TSG_Point p = m_Georeferencer.World_to_Image(px, py, pz);
if( bFlip )
{
p.y = (Get_NY() - 1) - p.y;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
if( pInput->asGrid(i)->Get_Value(p.x, p.y, pz, Resampling) )
{
pOutput->asGrid(i)->Set_Value(x, y, pz);
}
else
{
pOutput->asGrid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CTable_Text_Import_Fixed_Cols::On_Execute(void)
{
bool bHeader;
int i, nChars, iField, nFields, *iFirst, *iLength;
CSG_String sLine;
CSG_File Stream;
CSG_Table *pTable;
//-----------------------------------------------------
pTable = Parameters("TABLE") ->asTable();
bHeader = Parameters("HEADLINE") ->asBool();
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R, true) )
{
Message_Add(_TL("file could not be opened"));
return( false );
}
if( !Stream.Read_Line(sLine) || (nChars = (int)sLine.Length()) <= 0 )
{
Message_Add(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
pTable->Destroy();
pTable->Set_Name(SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
switch( Parameters("FIELDDEF")->asInt() )
{
//-----------------------------------------------------
case 0:
{
CSG_Parameters *pBreaks = Get_Parameters("BREAKS");
pBreaks->Del_Parameters();
for(i=0; i<nChars; i++)
{
pBreaks->Add_Value(NULL,
CSG_String::Format(SG_T("%03d"), i),
CSG_String::Format(SG_T("%03d %c"), i + 1, sLine[i]),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
if( !Dlg_Parameters("BREAKS") )
{
return( false );
}
//-------------------------------------------------
for(i=0, nFields=1; i<pBreaks->Get_Count(); i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
nFields++;
}
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(i=0, iField=1; i<pBreaks->Get_Count() && iField<nFields; i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
iFirst[iField++] = i + 1;
}
}
//-------------------------------------------------
for(iField=0; iField<nFields; iField++)
{
iLength[iField] = (iField < nFields - 1 ? iFirst[iField + 1] : (int)sLine.Length()) - iFirst[iField];
pTable->Add_Field(bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1), SG_DATATYPE_String);
}
}
break;
//-----------------------------------------------------
case 1:
{
CSG_Parameters *pFields = Get_Parameters("FIELDS");
pFields->Del_Parameters();
nFields = Parameters("NFIELDS")->asInt();
for(iField=0; iField<nFields; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
CSG_Parameter *pNode = pFields->Add_Node(NULL, SG_T("NODE") + s, _TL("Field") + s, _TL(""));
pFields->Add_Value (pNode, SG_T("LENGTH") + s, _TL("Length"), _TL(""), PARAMETER_TYPE_Int, 1, 1, true);
// pFields->Add_Value (pNode, SG_T("IMPORT") + s, _TL("Import"), _TL(""), PARAMETER_TYPE_Bool, true);
pFields->Add_Choice (pNode, SG_T("TYPE") + s, _TL("Type") , _TL(""), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"),
_TL("text"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte float"),
_TL("8 byte float"))
);
}
if( !Dlg_Parameters("FIELDS") )
{
return( false );
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
iFirst [iField] = i;
iLength[iField] = pFields->Get_Parameter(SG_T("LENGTH") + s)->asInt();
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1);
switch( pFields->Get_Parameter(SG_T("TYPE") + s)->asInt() )
{
default:
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
//-----------------------------------------------------
case 2:
{
CSG_Table *pList = Parameters("LIST")->asTable();
nFields = pList->Get_Count();
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
iFirst [iField] = i;
iLength[iField] = pList->Get_Record(iField)->asInt(1);
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String(pList->Get_Record(iField)->asString(0));
switch( pList->Get_Record(iField)->asInt(2) )
{
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
default:
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
}
//-----------------------------------------------------
if( bHeader )
{
Stream.Read_Line(sLine);
}
//-----------------------------------------------------
int fLength = Stream.Length();
do
{
if( sLine.Length() == nChars )
{
CSG_Table_Record *pRecord = pTable->Add_Record();
for(iField=0; iField<nFields; iField++)
{
pRecord->Set_Value(iField, sLine.Mid(iFirst[iField], iLength[iField]));
}
}
}
while( Stream.Read_Line(sLine) && Set_Progress(Stream.Tell(), fLength) );
//-----------------------------------------------------
delete[](iFirst);
delete[](iLength);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPROJ4_Grid::On_Execute_Conversion(void)
{
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
CSG_Shapes *pShapes;
m_Interpolation = Parameters("INTERPOLATION")->asInt();
//-----------------------------------------------------
if( m_bInputList )
{
CSG_Parameter_Grid_List *pSources = Parameters("SOURCE")->asGridList();
CSG_Parameter_Grid_List *pTargets = Parameters("TARGET")->asGridList();
if( pSources->Get_Count() < 1 )
{
return( false );
}
pSource = pSources->asGrid(0);
pGrid = NULL;
pShapes = NULL;
Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create new user defined grid...
if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") )
{
pGrid = m_Grid_Target.Get_User(Type);
}
break;
case 1: // select grid system...
if( Dlg_Parameters("<") && Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System()->is_Valid() )
{
pGrid = SG_Create_Grid(*Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), Type);
}
break;
case 2: // shapes...
if( Dlg_Parameters("GET_SHAPES") )
{
pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes();
if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE )
{
Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes());
}
}
break;
}
//-------------------------------------------------
if( pShapes )
{
Parameters("SHAPES")->Set_Value(pShapes);
return( Set_Shapes(pSources, pShapes) );
}
if( pGrid )
{
pTargets->Del_Items();
pTargets->Add_Item(pGrid);
Init_Target(pSource, pGrid);
for(int i=1; i<pSources->Get_Count(); i++)
{
pTargets->Add_Item(SG_Create_Grid(pGrid->Get_System(), m_Interpolation == 0 ? pSources->asGrid(i)->Get_Type() : SG_DATATYPE_Float));
Init_Target(pSources->asGrid(i), pTargets->asGrid(i));
}
return( Set_Grids(pSources, pTargets) );
}
}
//-----------------------------------------------------
else
{
pSource = Parameters("SOURCE")->asGrid();
pGrid = NULL;
pShapes = NULL;
Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create new user defined grid...
if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") )
{
pGrid = m_Grid_Target.Get_User(Type);
}
break;
case 1: // select grid...
if( Dlg_Parameters("GET_GRID") )
{
pGrid = m_Grid_Target.Get_Grid(Type);
}
break;
case 2: // shapes...
if( Dlg_Parameters("GET_SHAPES") )
{
pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes();
if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE )
{
Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes());
}
}
break;
}
//-------------------------------------------------
if( pShapes )
{
Parameters("SHAPES")->Set_Value(pShapes);
return( Set_Shapes(pSource, pShapes) );
}
if( pGrid )
{
return( Set_Grid(pSource, pGrid) );
}
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Get_Target_System(const CSG_Grid_System &System, bool bEdge)
{
int x, y, Resolution;
TSG_Rect Extent;
Extent.xMin = Extent.yMin = 1.0;
Extent.xMax = Extent.yMax = 0.0;
Get_MinMax(Extent, System.Get_XMin(), System.Get_YMin());
Get_MinMax(Extent, System.Get_XMax(), System.Get_YMin());
Get_MinMax(Extent, System.Get_XMin(), System.Get_YMax());
Get_MinMax(Extent, System.Get_XMax(), System.Get_YMax());
Resolution = 256;
switch( 1 )
{
case 1: // edges
{
double d;
int yStep = 1 + System.Get_NY() / Resolution;
for(y=0, d=System.Get_YMin(); y<System.Get_NY(); y+=yStep, d+=yStep*System.Get_Cellsize())
{
Get_MinMax(Extent, System.Get_XMin(), d);
Get_MinMax(Extent, System.Get_XMax(), d);
}
int xStep = 1 + System.Get_NX() / Resolution;
for(x=0, d=System.Get_XMin(); x<System.Get_NX(); x+=xStep, d+=xStep*System.Get_Cellsize())
{
Get_MinMax(Extent, d, System.Get_YMin());
Get_MinMax(Extent, d, System.Get_YMax());
}
}
break;
case 2: // all cells
{
TSG_Point p;
int xStep = 1 + System.Get_NX() / Resolution;
int yStep = 1 + System.Get_NY() / Resolution;
for(y=0, p.y=System.Get_YMin(); y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y+=yStep, p.y+=yStep*System.Get_Cellsize())
{
for(x=0, p.x=System.Get_XMin(); x<System.Get_NX(); x+=xStep, p.x+=xStep*System.Get_Cellsize())
{
Get_MinMax(Extent, p.x, p.y);
}
}
}
break;
}
return( is_Progress() && Extent.xMin < Extent.xMax && Extent.yMin < Extent.yMax
&& m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, System.Get_NY())
&& Dlg_Parameters("TARGET") && m_Grid_Target.Get_System().is_Valid()
);
}
//---------------------------------------------------------
bool CGrid_Merge::Initialize(void)
{
//-----------------------------------------------------
m_pMosaic = NULL;
m_Overlap = Parameters("OVERLAP" )->asInt();
m_pGrids = Parameters("GRIDS" )->asGridList();
m_dBlend = Parameters("BLEND_DIST")->asDouble();
if( m_pGrids->Get_Count() < 2 )
{
Error_Set(_TL("nothing to do, there are less than two grids in input list."));
return( false );
}
Set_Target(Get_Parameters("TARGET"), m_pGrids); Dlg_Parameters("TARGET"); // if called from saga_cmd
//-----------------------------------------------------
switch( Parameters("INTERPOL")->asInt() )
{
default:
case 0: m_Interpolation = GRID_INTERPOLATION_NearestNeighbour; break; // Nearest Neighbor
case 1: m_Interpolation = GRID_INTERPOLATION_Bilinear; break; // Bilinear Interpolation
case 2: m_Interpolation = GRID_INTERPOLATION_InverseDistance; break; // Inverse Distance Interpolation
case 3: m_Interpolation = GRID_INTERPOLATION_BicubicSpline; break; // Bicubic Spline Interpolation
case 4: m_Interpolation = GRID_INTERPOLATION_BSpline; break; // B-Spline Interpolation
}
//-----------------------------------------------------
TSG_Data_Type Type;
switch( Parameters("TYPE")->asInt() )
{
default: Type = SG_DATATYPE_Float; break;
case 0: Type = SG_DATATYPE_Bit; break;
case 1: Type = SG_DATATYPE_Byte; break;
case 2: Type = SG_DATATYPE_Char; break;
case 3: Type = SG_DATATYPE_Word; break;
case 4: Type = SG_DATATYPE_Short; break;
case 5: Type = SG_DATATYPE_DWord; break;
case 6: Type = SG_DATATYPE_Int; break;
case 7: Type = SG_DATATYPE_Float; break;
case 8: Type = SG_DATATYPE_Double; break;
}
if( (m_pMosaic = m_Grid_Target.Get_Grid(Type)) == NULL )
{
return( false );
}
if( m_pMosaic->Get_Type() != Type && !m_pMosaic->Create(m_pMosaic->Get_System(), Type) )
{
return( false );
}
//-----------------------------------------------------
m_pMosaic->Set_Name(Parameters("NAME")->asString());
m_pMosaic->Assign_NoData();
//-----------------------------------------------------
switch( m_Overlap )
{
case 4: // mean
if( !m_Weights.Create(m_pMosaic->Get_System(), m_pGrids->Get_Count() < 256 ? SG_DATATYPE_Byte : SG_DATATYPE_Word) )
{
Error_Set(_TL("could not create weights grid"));
return( false );
}
break;
case 6: // feathering
if( !m_Weights.Create(m_pMosaic->Get_System(), SG_DATATYPE_Word) )
{
Error_Set(_TL("could not create weights grid"));
return( false );
}
m_Weights.Set_Scaling(m_pMosaic->Get_Cellsize());
break;
}
return( true );
}
//---------------------------------------------------------
bool CParam_Scale::On_Execute(void)
{
//-----------------------------------------------------
bool bConstrain;
int Index[6];
double zScale, Tol_Slope, Tol_Curve;
CSG_Matrix Normal;
//-----------------------------------------------------
bConstrain = Parameters("CONSTRAIN")->asBool();
zScale = Parameters("ZSCALE" )->asDouble(); if( zScale <= 0.0 ) { zScale = 1.0; }
Tol_Slope = Parameters("TOL_SLOPE")->asDouble();
Tol_Curve = Parameters("TOL_CURVE")->asDouble();
m_pDEM = Parameters("DEM" )->asGrid();
//-----------------------------------------------------
CSG_Grid *pFeature = Parameters("FEATURES" )->asGrid();
CSG_Grid *pElevation = Parameters("ELEVATION")->asGrid();
CSG_Grid *pSlope = Parameters("SLOPE" )->asGrid();
CSG_Grid *pAspect = Parameters("ASPECT" )->asGrid();
CSG_Grid *pProfC = Parameters("PROFC" )->asGrid();
CSG_Grid *pPlanC = Parameters("PLANC" )->asGrid();
CSG_Grid *pLongC = Parameters("LONGC" )->asGrid();
CSG_Grid *pCrosC = Parameters("CROSC" )->asGrid();
CSG_Grid *pMiniC = Parameters("MINIC" )->asGrid();
CSG_Grid *pMaxiC = Parameters("MAXIC" )->asGrid();
//-----------------------------------------------------
if( !Get_Weights() )
{
return( false );
}
if( !Get_Normal(Normal) )
{
return( false );
}
// To constrain the quadtratic through the central cell, ignore the calculations involving the
// coefficient f. Since these are all in the last row and column of the matrix, simply redimension.
if( !SG_Matrix_LU_Decomposition(bConstrain ? 5 : 6, Index, Normal.Get_Data()) )
{
return( false );
}
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
CSG_Vector Observed;
double elevation, slope, aspect, profc, planc, longc, crosc, minic, maxic;
if( Get_Observed(x, y, Observed, bConstrain)
&& SG_Matrix_LU_Solve(bConstrain ? 5 : 6, Index, Normal, Observed.Get_Data()) )
{
Get_Parameters(zScale, Observed.Get_Data(), elevation, slope, aspect, profc, planc, longc, crosc, minic, maxic);
GRID_SET_VALUE(pFeature , Get_Feature(slope, minic, maxic, crosc, Tol_Slope, Tol_Curve));
GRID_SET_VALUE(pElevation, elevation + m_pDEM->asDouble(x, y)); // Add central elevation back
GRID_SET_VALUE(pSlope , slope);
GRID_SET_VALUE(pAspect , aspect);
GRID_SET_VALUE(pProfC , profc);
GRID_SET_VALUE(pPlanC , planc);
GRID_SET_VALUE(pLongC , longc);
GRID_SET_VALUE(pCrosC , crosc);
GRID_SET_VALUE(pMiniC , minic);
GRID_SET_VALUE(pMaxiC , maxic);
}
else
{
GRID_SET_NODATA(pFeature);
GRID_SET_NODATA(pElevation);
GRID_SET_NODATA(pSlope);
GRID_SET_NODATA(pAspect);
GRID_SET_NODATA(pProfC);
GRID_SET_NODATA(pPlanC);
GRID_SET_NODATA(pLongC);
GRID_SET_NODATA(pCrosC);
GRID_SET_NODATA(pMiniC);
GRID_SET_NODATA(pMaxiC);
}
}
}
//-----------------------------------------------------
CSG_Parameter *pLUT = DataObject_Get_Parameter(pFeature, "LUT");
if( pLUT && pLUT->asTable() )
{
pLUT->asTable()->Del_Records();
LUT_SET_CLASS(FLAT , _TL("Planar" ), SG_GET_RGB(180, 180, 180));
LUT_SET_CLASS(PIT , _TL("Pit" ), SG_GET_RGB( 0, 0, 0));
LUT_SET_CLASS(CHANNEL, _TL("Channel" ), SG_GET_RGB( 0, 0, 255));
LUT_SET_CLASS(PASS , _TL("Pass (saddle)"), SG_GET_RGB( 0, 255, 0));
LUT_SET_CLASS(RIDGE , _TL("Ridge" ), SG_GET_RGB(255, 255, 0));
LUT_SET_CLASS(PEAK , _TL("Peak" ), SG_GET_RGB(255, 0, 0));
DataObject_Set_Parameter(pFeature, pLUT);
DataObject_Set_Parameter(pFeature, "COLORS_TYPE", 1); // Color Classification Type: Lookup Table
}
//-----------------------------------------------------
DataObject_Set_Colors(pSlope , 11, SG_COLORS_YELLOW_RED);
DataObject_Set_Colors(pAspect, 11, SG_COLORS_ASPECT_3);
DataObject_Set_Colors(pProfC , 11, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(pPlanC , 11, SG_COLORS_RED_GREY_BLUE, false);
DataObject_Set_Colors(pLongC , 11, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(pCrosC , 11, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(pMiniC , 11, SG_COLORS_RED_GREY_BLUE, true);
DataObject_Set_Colors(pMaxiC , 11, SG_COLORS_RED_GREY_BLUE, true);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CShapes_Cut::Get_Extent(CSG_Rect &r)
{
m_pPolygons = NULL;
switch( Parameters("TARGET")->asInt() )
{
//-----------------------------------------------------
case 0: // user defined
Get_Parameters("CUT")->Get_Parameter("AX")->Set_Value(r.Get_XMin());
Get_Parameters("CUT")->Get_Parameter("AY")->Set_Value(r.Get_YMin());
Get_Parameters("CUT")->Get_Parameter("BX")->Set_Value(r.Get_XMax());
Get_Parameters("CUT")->Get_Parameter("BY")->Set_Value(r.Get_YMax());
Get_Parameters("CUT")->Get_Parameter("DX")->Set_Value(r.Get_XRange());
Get_Parameters("CUT")->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
Get_Parameters("CUT")->Get_Parameter("AX")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("AY")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("BX")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("BY")->asDouble()
);
return( true );
}
break;
//-----------------------------------------------------
case 1: // grid project
if( Dlg_Parameters("GRID") )
{
r.Assign(Get_Parameters("GRID")->Get_Parameter("GRID")->asGrid_System()->Get_Extent());
return( true );
}
break;
//-----------------------------------------------------
case 2: // shapes extent
if( Dlg_Parameters("SHAPES") )
{
r.Assign(Get_Parameters("SHAPES")->Get_Parameter("SHAPES")->asShapes()->Get_Extent());
return( true );
}
break;
//-----------------------------------------------------
case 3: // polygons
if( Dlg_Parameters("POLYGONS") )
{
r.Assign(Get_Parameters("POLYGONS")->Get_Parameter("POLYGONS")->asShapes()->Get_Extent());
m_pPolygons = Get_Parameters("POLYGONS")->Get_Parameter("POLYGONS")->asShapes();
return( true );
}
break;
}
return( false );
}
//---------------------------------------------------------
bool CGeoref_Grid::Get_Conversion(void)
{
//-----------------------------------------------------
CSG_Rect Extent;
CSG_Grid *pSource = Parameters("GRID")->asGrid();
//-----------------------------------------------------
if( !Get_Target_Extent(Extent, true) || !m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, pSource->Get_NY()) )
{
Error_Set(_TL("failed to estimate target extent"));
return( false );
}
if( !Dlg_Parameters("TARGET") )
{
return( false );
}
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
CSG_Grid *pReferenced = m_Grid_Target.Get_Grid(Resampling == GRID_RESAMPLING_NearestNeighbour ? pSource->Get_Type() : SG_DATATYPE_Float);
if( !pReferenced )
{
Error_Set(_TL("failed to initialize target grid"));
return( false );
}
//-----------------------------------------------------
if( !Set_Grid(pSource, pReferenced, Resampling) )
{
Error_Set(_TL("failed to project target grid"));
return( false );
}
//-----------------------------------------------------
CSG_Parameters P;
if( DataObject_Get_Parameters(pSource, P) )
{
DataObject_Add(pReferenced);
DataObject_Set_Parameters(pReferenced, P);
}
//-----------------------------------------------------
return( true );
}