//---------------------------------------------------------
bool CSADO_SolarRadiation::Get_Insolation(void)
{
//-----------------------------------------------------
if( Initialise() )
{
if( m_bMoment )
{
Get_Insolation(m_Day_A, m_Hour);
Finalise();
}
//-------------------------------------------------
else
{
for(int Day=m_Day_A; Day<=m_Day_B && Process_Get_Okay(false); Day+=m_dDays)
{
for(double Hour=m_Hour; Hour<24.0 && Process_Get_Okay(false); Hour+=m_dHour)
{
Process_Set_Text(CSG_String::Format(SG_T("%s: %d(%d-%d), %s: %f"), _TL("Day"), Day, m_Day_A, m_Day_B, _TL("Hour"), Hour));
if( m_bUpdateDirect ) m_pSumDirect->Assign(0.0);
if( m_bUpdateDiffus ) m_pSumDiffus->Assign(0.0);
if( m_bUpdateTotal ) m_pSumTotal ->Assign(0.0);
if( Get_Insolation(Day, Hour) )
{
if( m_bUpdateDirect )
{
m_TmpDirect += *m_pSumDirect;
DataObject_Update(m_pSumDirect);
}
if( m_bUpdateDiffus )
{
m_TmpDiffus += *m_pSumDiffus;
DataObject_Update(m_pSumDiffus);
}
if( m_bUpdateTotal )
{
m_TmpTotal += *m_pSumTotal;
DataObject_Update(m_pSumTotal);
}
}
}
}
Finalise(m_dHour / (24.0 * (1 + m_Day_B - m_Day_A))); // *m_pSumDirect *= m_dHour / D->size();
}
}
//-----------------------------------------------------
return( true );
}
///////////////////////////////////////////////////////////
//---------------------------------------------------------
// This function modifies the incoming integer variables!!!
//---------------------------------------------------------
bool CGrid_Polygon_Clip::Get_Extent(int &xMin, int &xCount, int &yMin, int &yCount, CSG_Grid *pMask, CSG_Parameter_Grid_List *pGrids)
{
bool bFound;
for(yMin=0, bFound=false; yMin<Get_NY() && !bFound && Process_Get_Okay(true); yMin++)
{
for(int x=0; x<Get_NX() && !bFound; x++)
{
bFound = is_InGrid(x, yMin, pMask, pGrids);
}
}
yMin--;
//-----------------------------------------------------
if( yMin < Get_NY() && Process_Get_Okay() )
{
int xMax, yMax;
for(yMax=Get_NY()-1, bFound=false; yMax>=yMin && !bFound && Process_Get_Okay(true); yMax--)
{
for(int x=0; x<Get_NX() && !bFound; x++)
{
bFound = is_InGrid(x, yMax, pMask, pGrids);
}
}
for(xMin=0, bFound=false; xMin<Get_NX() && !bFound && Process_Get_Okay(true); xMin++)
{
for(int y=yMin; y<yMax && !bFound; y++)
{
bFound = is_InGrid(xMin, y, pMask, pGrids);
}
}
xMin--;
for(xMax=Get_NX()-1, bFound=false; xMax>=xMin && !bFound && Process_Get_Okay(true); xMax--)
{
for(int y=yMin; y<yMax && !bFound; y++)
{
bFound = is_InGrid(xMax, y, pMask, pGrids);
}
}
xCount = 1 + xMax - xMin;
yCount = 1 + yMax - yMin;
return( xCount > 0 && yCount > 0 );
}
return( false );
}
//---------------------------------------------------------
bool CShapes_Split::On_Execute(void)
{
int x, y, nx, ny, Method;
CSG_Shapes *pShapes, *pCut, *pExtent;
//-----------------------------------------------------
pShapes = Parameters("SHAPES") ->asShapes();
pExtent = Parameters("EXTENT") ->asShapes();
nx = Parameters("NX") ->asInt();
ny = Parameters("NY") ->asInt();
Method = Parameters("METHOD") ->asInt();
Parameters("CUTS")->asShapesList()->Del_Items();
//-----------------------------------------------------
if( pShapes->is_Valid() )
{
double dx, dy;
TSG_Rect r;
dx = pShapes->Get_Extent().Get_XRange() / nx;
dy = pShapes->Get_Extent().Get_YRange() / ny;
for(y=0; y<ny && Process_Get_Okay(false); y++)
{
r.yMin = pShapes->Get_Extent().Get_YMin() + y * dy;
r.yMax = r.yMin + dy;
for(x=0; x<nx && Process_Get_Okay(false); x++)
{
r.xMin = pShapes->Get_Extent().Get_XMin() + x * dx;
r.xMax = r.xMin + dx;
Cut_Set_Extent(r, pExtent, y == 0 && x == 0);
Process_Set_Text(CSG_String::Format(SG_T("%d/%d"), y * nx + (x + 1), nx * ny));
if( (pCut = Cut_Shapes(r, Method, pShapes)) != NULL )
{
pCut->Set_Name(CSG_String::Format(SG_T("%s [%d][%d]"), pShapes->Get_Name(), 1 + x, 1 + y));
Parameters("CUTS")->asShapesList()->Add_Item(pCut);
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CPolygon_Vertex_Check::On_Execute(void)
{
//-----------------------------------------------------
CSG_Shapes *pPolygons = Parameters("POLYGONS")->asShapes();
if( Parameters("CHECKED")->asShapes() && Parameters("CHECKED")->asShapes() != pPolygons )
{
CSG_Shapes *pCopy = Parameters("CHECKED")->asShapes();
pCopy->Create(*pPolygons);
pCopy->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pPolygons->Get_Name(), _TL("checked")));
pPolygons = pCopy;
}
if( (m_pAdded = Parameters("ADDED")->asShapes()) != NULL )
{
m_pAdded->Create(SHAPE_TYPE_Point, _TL("Added"));
}
double Epsilon = Parameters("EPSILON")->asDouble();
//-----------------------------------------------------
for(int iPolygon=0; iPolygon<pPolygons->Get_Count()-1 && Set_Progress(iPolygon, pPolygons->Get_Count()-1); iPolygon++)
{
CSG_Shape_Polygon *pA = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iPolygon);
for(int jPolygon=iPolygon+1; jPolygon<pPolygons->Get_Count() && Process_Get_Okay(); jPolygon++)
{
CSG_Shape_Polygon *pB = (CSG_Shape_Polygon *)pPolygons->Get_Shape(jPolygon);
for(int iPart=0; iPart<pA->Get_Part_Count() && Process_Get_Okay(); iPart++)
{
for(int jPart=0; jPart<pB->Get_Part_Count() && Process_Get_Okay(); jPart++)
{
if( pA->Get_Part(iPart)->Get_Extent().Intersects(pB->Get_Part(jPart)->Get_Extent()) )
{
Check_Vertices(pA->Get_Part(iPart), pB->Get_Part(jPart), Epsilon);
Check_Vertices(pB->Get_Part(jPart), pA->Get_Part(iPart), Epsilon);
}
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CExercise_10::On_Execute(void)
{
bool bAlive;
int x, y, i;
CSG_Colors Colors;
//-----------------------------------------------------
// General initialisations...
m_pLife = Parameters("RESULT")->asGrid();
m_nColors = Parameters("COLORS")->asInt();
Colors.Set_Count(m_nColors + 1);
Colors.Set_Ramp(SG_GET_RGB(127, 127, 127), SG_GET_RGB(0, 0, 0));
Colors.Set_Color(0, SG_GET_RGB(255, 255, 255));
DataObject_Set_Colors(m_pLife, Colors);
//-----------------------------------------------------
// Initialise life's world...
if( Parameters("REFRESH")->asBool() )
{
srand((unsigned)time(NULL));
for(y=0; y<Get_NY(); y++)
{
for(x=0; x<Get_NX(); x++)
{
m_pLife->Set_Value(x, y, rand() > RAND_MAX / 2 ? 0 : 1);
}
}
}
//-----------------------------------------------------
// Execution...
m_pTemp = SG_Create_Grid(m_pLife, SG_DATATYPE_Byte);
for(i=1, bAlive=true; bAlive && Process_Get_Okay(true); i++)
{
Process_Set_Text(CSG_String::Format(SG_T("%d %s"), i, _TL("Life Cycle")));
if( (bAlive = Next_Step()) == false )
{
Message_Add(CSG_String::Format(SG_T("%s %d %s\n"), _TL("Dead after"), i, _TL("Life Cycles")));
}
}
delete(m_pTemp);
//-----------------------------------------------------
// Finish...
return( true );
}
//---------------------------------------------------------
bool CImport_Clip_Resample::On_Execute(void)
{
//-----------------------------------------------------
CSG_Strings Files;
if( !Parameters("FILES")->asFilePath()->Get_FilePaths(Files) || Files.Get_Count() == 0 )
{
return( false );
}
//-----------------------------------------------------
m_pGrids = Parameters("GRIDS")->asGridList();
m_pGrids->Del_Items();
//-----------------------------------------------------
for(int i=0; i<Files.Get_Count() && Process_Get_Okay(); i++)
{
Load_File(Files[i]);
}
//-----------------------------------------------------
if( m_pGrids->Get_Count() == 0 )
{
Error_Set(_TL("no grids have been imported"));
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Fill::On_Execute(void)
{
CSG_Shapes *pPoints = Parameters("POINTS")->asShapes();
if( !pPoints->is_Valid() || !pPoints->Get_Extent().Intersects(Get_System().Get_Extent()) || !Parameters_Set(Parameters) )
{
return( false );
}
//-----------------------------------------------------
int nReplaced = 0;
#define GET_NPOINTS (bSelection ? pPoints->Get_Selection_Count() : pPoints->Get_Count())
#define GET_POINT(i) (bSelection ? pPoints->Get_Selection(i)->Get_Point(0) : pPoints->Get_Shape(i)->Get_Point(0))
bool bSelection = pPoints->Get_Selection_Count() > 0;
for(int i=0; i<GET_NPOINTS && Process_Get_Okay(); i++)
{
nReplaced += Fill(GET_POINT(i));
}
Message_Fmt("\n%d %s\n", nReplaced, _TL("replacements"));
return( true );
}
//---------------------------------------------------------
bool CGridding_Spline_MBA_Grid::_Get_Difference(CSG_Grid &Phi)
{
int xPoint, yPoint, nErrors;
double x, y, z, zMax, zMean;
TSG_Point_Z p;
CSG_String s;
//-----------------------------------------------------
for(yPoint=0, p.y=m_Points.Get_YMin(), zMax=0.0, nErrors=0, zMean=0.0; yPoint<m_Points.Get_NY() && Set_Progress(yPoint, m_Points.Get_NY()); yPoint++, p.y+=m_Points.Get_Cellsize())
{
for(xPoint=0, p.x=m_Points.Get_XMin(); xPoint<m_Points.Get_NX(); xPoint++, p.x+=m_Points.Get_Cellsize())
{
if( !m_Points.is_NoData(xPoint, yPoint) )
{
x = (p.x - Phi.Get_XMin()) / Phi.Get_Cellsize();
y = (p.y - Phi.Get_YMin()) / Phi.Get_Cellsize();
z = m_Points.asDouble(xPoint, yPoint) - BA_Get_Value(x, y, Phi);
m_Points.Set_Value(xPoint, yPoint, z);
if( (z = fabs(z)) > m_Epsilon )
{
nErrors ++;
zMean += fabs(z);
if( fabs(z) > zMax )
{
zMax = fabs(z);
}
}
else
{
// m_Points.Set_Value(xPoint, yPoint, 0.0);
m_Points.Set_NoData(xPoint, yPoint);
}
}
}
}
if( nErrors > 0 )
{
zMean /= nErrors;
}
//-----------------------------------------------------
int i = 1 + (int)(0.5 + log(Phi.Get_NX() - 4.0) / log(2.0));
s.Printf(SG_T("%s:%d, %s:%d, %s:%f, %s:%f"),
_TL("level"), i,
_TL("error"), nErrors,
_TL("max") , zMax,
_TL("mean") , zMean
);
Process_Set_Text(s);
Message_Add (s);
return( zMax >= m_Epsilon && i < m_Level_Max && Process_Get_Okay(false) );
}
//---------------------------------------------------------
bool CCRS_Transform_Shapes::On_Execute_Transformation(void)
{
if( m_bList )
{
CSG_Parameter_Shapes_List *pSources, *pTargets;
pSources = Parameters("SOURCE")->asShapesList();
pTargets = Parameters("TARGET")->asShapesList();
pTargets->Del_Items();
for(int i=0; i<pSources->Get_Count() && Process_Get_Okay(false); i++)
{
CSG_Shapes *pSource = pSources->asShapes(i);
CSG_Shapes *pTarget = SG_Create_Shapes(pSource);
if( Transform(pSource, pTarget) )
{
pTargets->Add_Item(pTarget);
}
else
{
delete(pTarget);
}
}
return( pTargets->Get_Count() > 0 );
}
else
{
CSG_Shapes *pSource = Parameters("SOURCE")->asShapes();
CSG_Shapes *pTarget = Parameters("TARGET")->asShapes();
if( pSource == pTarget )
{
pTarget = SG_Create_Shapes(pSource);
if( Transform(pSource, pTarget) )
{
pSource->Assign(pTarget);
return( true );
}
else
{
delete(pTarget);
return( false );
}
}
else
{
pTarget->Create(pSource->Get_Type(), pSource->Get_Name(), pSource, pSource->Get_Vertex_Type());
}
return( Transform(pSource, pTarget) );
}
}
//---------------------------------------------------------
bool CPROJ4_Shapes::On_Execute_Conversion(void)
{
bool bResult = false;
CSG_Shapes *pSource, *pTarget;
//-----------------------------------------------------
if( m_bInputList )
{
CSG_Parameter_Shapes_List *pSources, *pTargets;
pSources = Parameters("SOURCE")->asShapesList();
pTargets = Parameters("TARGET")->asShapesList();
pTargets->Del_Items();
for(int i=0; i<pSources->Get_Count() && Process_Get_Okay(false); i++)
{
pSource = pSources->asShapes(i);
pTarget = SG_Create_Shapes();
if( _Get_Conversion(pSource, pTarget) )
{
bResult = true;
pTargets->Add_Item(pTarget);
}
else
{
delete( pTarget );
}
}
}
else
{
bool bCopy;
pSource = Parameters("SOURCE")->asShapes();
pTarget = Parameters("TARGET")->asShapes();
if( (bCopy = pSource == pTarget) == true )
{
pTarget = SG_Create_Shapes();
}
//-------------------------------------------------
bResult = _Get_Conversion(pSource, pTarget);
//-------------------------------------------------
if( bCopy )
{
pSource->Assign(pTarget);
delete( pTarget );
}
}
return( bResult );
}
//---------------------------------------------------------
inline void CDXF_Import::Check_Process(void)
{
static int iProcess = 0;
if( (iProcess++) % 100 == 0 )
{
Process_Get_Okay();
}
}
//---------------------------------------------------------
bool CLife::On_Execute(void)
{
//-----------------------------------------------------
m_pLife = m_Grid_Target.Get_Grid("LIFE", SG_DATATYPE_Byte);
if( !m_pLife )
{
Error_Set(_TL("could not create target grid"));
return( false );
}
//-----------------------------------------------------
m_nColors = Parameters("FADECOLOR")->asInt();
for(int y=0; y<m_pLife->Get_NY(); y++)
{
for(int x=0; x<m_pLife->Get_NX(); x++)
{
m_pLife->Set_Value(x, y, CSG_Random::Get_Uniform(0, 100) < 50 ? 0 : m_nColors);
}
}
//-----------------------------------------------------
m_pLife->Set_Name(_TL("Conway's Game of Life"));
m_pLife->Set_NoData_Value(-1);
DataObject_Add (m_pLife);
DataObject_Set_Colors(m_pLife, 11, SG_COLORS_WHITE_BLUE);
DataObject_Update (m_pLife, 0, m_nColors, SG_UI_DATAOBJECT_SHOW);
//-----------------------------------------------------
int i;
m_Count.Create(m_pLife->Get_System(), SG_DATATYPE_Byte);
for(i=1; Process_Get_Okay(true) && Next_Cycle(i > m_nColors); i++)
{
Process_Set_Text(CSG_String::Format("%s: %d", _TL("Life Cycle"), i));
DataObject_Update(m_pLife, 0, m_nColors);
}
m_Count.Destroy();
//-----------------------------------------------------
if( is_Progress() )
{
Message_Add(CSG_String::Format("\n%s %d %s\n", _TL("Dead after"), i, _TL("Life Cycles")), false);
}
return( true );
}
//---------------------------------------------------------
bool CSelect_Location::Do_Select(CSG_Shape *pShape, int Condition)
{
for(int i=0; i<m_pLocations->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Shape *pLocation = m_pLocations->Get_Shape(i);
if( pShape->Intersects(pLocation->Get_Extent()) )
{
switch( Condition )
{
case 0: // intersect
if( pLocation->Intersects(pShape) )
{
return( true );
}
break;
case 1: // are completely within
if( pLocation->Intersects(pShape) == INTERSECTION_Contains )
{
return( true );
}
break;
case 2: // completely contain
if( pShape->Intersects(pLocation) == INTERSECTION_Contains )
{
return( true );
}
break;
case 3: // have their centroid in
if( ((CSG_Shape_Polygon *)pLocation)->Contains(pShape->Get_Centroid()) )
{
return( true );
}
break;
case 4: // contain the centroid of
if( ((CSG_Shape_Polygon *)pShape)->Contains(pLocation->Get_Centroid()) )
{
return( true );
}
break;
}
}
}
return( false );
}
//---------------------------------------------------------
bool CGridding_Spline_MBA::_Get_Difference(CSG_Grid &Phi)
{
int i, nErrors;
double x, y, z, zMax, zMean;
CSG_String s;
//-----------------------------------------------------
for(i=0, zMax=0.0, nErrors=0, zMean=0.0; i<m_Points.Get_Count(); i++)
{
x = (m_Points[i].x - Phi.Get_XMin()) / Phi.Get_Cellsize();
y = (m_Points[i].y - Phi.Get_YMin()) / Phi.Get_Cellsize();
z = (m_Points[i].z = m_Points[i].z - BA_Get_Value(x, y, Phi));
if( (z = fabs(z)) > m_Epsilon )
{
nErrors ++;
zMean += fabs(z);
if( fabs(z) > zMax )
{
zMax = fabs(z);
}
}
else
{
m_Points[i].z = 0.0;
}
}
if( nErrors > 0 )
{
zMean /= nErrors;
}
//-----------------------------------------------------
i = 1 + (int)(0.5 + log(Phi.Get_NX() - 4.0) / log(2.0));
s.Printf(SG_T("%s:%d, %s:%d, %s:%f, %s:%f"),
_TL("level"), i,
_TL("error"), nErrors,
_TL("max") , zMax,
_TL("mean") , zMean
);
Process_Set_Text(s);
Message_Add (s);
return( zMax >= m_Epsilon && i < m_Level_Max && Process_Get_Okay(false) );
}
//---------------------------------------------------------
bool CPolygon_Split_Parts::On_Execute(void)
{
bool bIgnoreLakes;
CSG_Shapes *pPolygons, *pParts;
pPolygons = Parameters("POLYGONS") ->asShapes();
pParts = Parameters("PARTS") ->asShapes();
bIgnoreLakes = Parameters("LAKES") ->asBool();
pParts->Create(SHAPE_TYPE_Polygon, CSG_String::Format(SG_T("%s [%s]"), pPolygons->Get_Name(), _TL("Parts")), pPolygons);
//-----------------------------------------------------
for(int iShape=0; iShape<pPolygons->Get_Count() && Set_Progress(iShape, pPolygons->Get_Count()); iShape++)
{
CSG_Shape *pPolygon = pPolygons->Get_Shape(iShape);
for(int iPart=0; iPart<pPolygon->Get_Part_Count() && Process_Get_Okay(); iPart++)
{
if( bIgnoreLakes || !((CSG_Shape_Polygon *)pPolygon)->is_Lake(iPart) )
{
CSG_Shape *pPart = pParts->Add_Shape(pPolygon, SHAPE_COPY_ATTR);
for(int iPoint=0; iPoint<pPolygon->Get_Point_Count(iPart); iPoint++)
{
pPart->Add_Point(pPolygon->Get_Point(iPoint, iPart));
}
if( !bIgnoreLakes )
{
for(int jPart=0; jPart<pPolygon->Get_Part_Count(); jPart++)
{
if( ((CSG_Shape_Polygon *)pPolygon)->is_Lake(jPart)
&& ((CSG_Shape_Polygon *)pPart)->Contains(pPolygon->Get_Point(0, jPart)) )
{
for(int jPoint=0, nPart=pPart->Get_Part_Count(); jPoint<pPolygon->Get_Point_Count(jPart); jPoint++)
{
pPart->Add_Point(pPolygon->Get_Point(jPoint, jPart), nPart);
}
}
}
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CGrid_Color_Rotate::On_Execute(void)
{
bool bDown;
int i;
long c;
CSG_Grid *pGrid;
CSG_Colors *pColors;
pGrid = Parameters("GRID")->asGrid();
pColors = Parameters("COLORS")->asColors();
bDown = Parameters("DIR")->asBool();
if( pColors->Get_Count() > 1 )
{
do
{
if( bDown )
{
for(i=0, c=pColors->Get_Color(0); i<pColors->Get_Count() - 1; i++)
{
pColors->Set_Color(i, pColors->Get_Color(i + 1));
}
pColors->Set_Color(pColors->Get_Count() - 1, c);
}
else
{
for(i=pColors->Get_Count()-1, c=pColors->Get_Color(pColors->Get_Count()-1); i>0; i--)
{
pColors->Set_Color(i, pColors->Get_Color(i - 1));
}
pColors->Set_Color(0, c);
}
DataObject_Set_Colors(pGrid, *pColors);
DataObject_Update(pGrid, true);
}
while( Process_Get_Okay(true) );
return( true );
}
return( false );
}
//---------------------------------------------------------
void CPolygon_Clip::Clip_Polygons(CSG_Shapes *pClips, CSG_Shapes *pInputs, CSG_Shapes *pOutputs)
{
for(int iClip=0; iClip<pClips->Get_Count() && Process_Get_Okay(); iClip++)
{
Process_Set_Text(CSG_String::Format(SG_T("%s: %d/%d"), _TL("clip features"), iClip + 1, pClips->Get_Count()));
CSG_Shape *pClip = pClips->Get_Shape(iClip);
for(int iInput=0; iInput<pInputs->Get_Count() && Set_Progress(iInput, pInputs->Get_Count()); iInput++)
{
CSG_Shape *pOutput = pOutputs->Add_Shape(pInputs->Get_Shape(iInput));
if( !SG_Polygon_Intersection(pOutput, pClip) )
{
pOutputs->Del_Shape(pOutputs->Get_Count() - 1);
}
}
}
}
//---------------------------------------------------------
bool CPolygon_Clip::On_Execute(void)
{
CSG_Shapes Clip, *pClip = Parameters("CLIP")->asShapes();
if( Parameters("DISSOLVE")->asBool() && Dissolve(pClip, &Clip) )
{
pClip = &Clip;
}
//-----------------------------------------------------
if( !Parameters("MULTIPLE")->asBool() ) // single input mode
{
return( Clip_Shapes(pClip,
Parameters("S_INPUT" )->asShapes(),
Parameters("S_OUTPUT")->asShapes()
));
}
//-----------------------------------------------------
else // multiple input mode
{
CSG_Parameter_Shapes_List *pInput = Parameters("M_INPUT" )->asShapesList();
CSG_Parameter_Shapes_List *pOutput = Parameters("M_OUTPUT")->asShapesList();
pOutput->Del_Items();
for(int i=0; i<pInput->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Shapes *pShapes = SG_Create_Shapes();
if( Clip_Shapes(pClip, pInput->asShapes(i), pShapes) )
{
pOutput->Add_Item(pShapes);
}
else
{
delete(pShapes);
}
}
return( pOutput->Get_Count() > 0 );
}
}
//---------------------------------------------------------
void CGrid_Gaps_Spline_Fill::Close_Gap(int x, int y)
{
//-----------------------------------------------------
m_nGaps ++;
m_nGapCells = 0;
m_iStack = 0;
m_Spline.Destroy();
Set_Gap_Cell(x, y);
while( m_iStack > 0 && m_nGapCells <= m_nGapCells_Max && Process_Get_Okay() )
{
Pop(x, y);
for(int i=0; i<8; i+=m_Neighbours)
{
Set_Gap_Cell(Get_xTo(i, x), Get_yTo(i, y));
}
}
//-----------------------------------------------------
if( m_nGapCells <= m_nGapCells_Max )
{
if( m_nPoints_Max == 0 || m_Spline.Get_Point_Count() <= m_nPoints_Max )
{
if( m_Spline.Create(m_Relaxation, true) )
{
for(int i=0; i<m_nGapCells; i++)
{
TSG_Point_Int p = m_GapCells[i];
m_pGrid->Set_Value(p.x, p.y, m_Spline.Get_Value(p.x, p.y));
}
}
}
else
{
Close_Gap();
}
}
}
//---------------------------------------------------------
bool CSAGA_Frame::ProgressBar_Set_Position(int Position)
{
if( Position < 0 )
{
m_pProgressBar->SetValue(0);
}
else
{
if( Position > 100 )
{
Position = 100;
}
if( m_pProgressBar->GetValue() != Position )
{
m_pProgressBar->SetValue(Position);
}
}
return( Process_Get_Okay(false) );
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
void CGrid_Gaps::Tension_Main(void)
{
int iStep, iStart, n;
double max, Threshold;
Threshold = Parameters("THRESHOLD")->asDouble();
n = Get_NX() > Get_NY() ? Get_NX() : Get_NY();
iStep = 0;
do { iStep++; } while( pow(2.0, iStep + 1) < n );
iStart = (int)pow(2.0, iStep);
pTension_Keep = new CSG_Grid(pResult, SG_DATATYPE_Byte);
pTension_Temp = new CSG_Grid(pResult);
pResult->Assign_NoData();
for(iStep=iStart; iStep>=1; iStep/=2)
{
Tension_Init(iStep);
do
{
max = Tension_Step(iStep);
Process_Set_Text(CSG_String::Format(SG_T("[%d] %s: %f"), iStep, _TL("max. change"), max));
}
while( max > Threshold && Process_Get_Okay(true) );
DataObject_Update(pResult, pInput->Get_ZMin(), pInput->Get_ZMax(), true);
}
delete(pTension_Keep);
delete(pTension_Temp);
}
//---------------------------------------------------------
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 CGrid_Merge::Set_Weight(CSG_Grid *pGrid)
{
int dBlend;
switch( m_Overlap )
{
default: // only feathering/blending
return( true );
case 5: // blending
dBlend = 1 + (int)(m_dBlend / pGrid->Get_Cellsize());
break;
case 6: // feathering
dBlend = 0;
break;
}
//-----------------------------------------------------
if( !m_Weight.Get_System().is_Equal(pGrid->Get_System()) )
{
if( !m_Weight.Create(pGrid->Get_System(), dBlend > 0 && dBlend < 255 ? SG_DATATYPE_Byte : SG_DATATYPE_Word) )
{
Error_Set(_TL("could not create distance grid"));
return( false );
}
}
//-----------------------------------------------------
int x, y, d;
for(y=0; y<pGrid->Get_NY() && Process_Get_Okay(); y++)
{
for(x=0, d=1; x<pGrid->Get_NX(); x++)
{
if( pGrid->is_NoData(x, y) )
m_Weight.Set_Value(x, y, d = 0);
else //if( m_Weight.asInt(x, y) > d )
m_Weight.Set_Value(x, y, d);
if( dBlend <= 0 || d < dBlend ) d++;
}
for(x=pGrid->Get_NX()-1, d=1; x>=0; x--)
{
if( pGrid->is_NoData(x, y) )
m_Weight.Set_Value(x, y, d = 0);
else if( m_Weight.asInt(x, y) > d )
m_Weight.Set_Value(x, y, d);
else
d = m_Weight.asInt(x, y);
if( dBlend <= 0 || d < dBlend ) d++;
}
}
for(x=0; x<pGrid->Get_NX() && Process_Get_Okay(); x++)
{
for(y=0, d=1; y<pGrid->Get_NY(); y++)
{
if( pGrid->is_NoData(x, y) )
m_Weight.Set_Value(x, y, d = 0);
else if( m_Weight.asInt(x, y) > d )
m_Weight.Set_Value(x, y, d);
else
d = m_Weight.asInt(x, y);
if( dBlend <= 0 || d < dBlend ) d++;
}
for(y=pGrid->Get_NY()-1, d=1; y>=0; y--)
{
if( pGrid->is_NoData(x, y) )
m_Weight.Set_Value(x, y, d = 0);
else if( m_Weight.asInt(x, y) > d )
m_Weight.Set_Value(x, y, d);
else
d = m_Weight.asInt(x, y);
if( dBlend <= 0 || d < dBlend ) d++;
}
}
//-----------------------------------------------------
switch( m_Overlap )
{
case 5: // blending
m_Weight.Set_Scaling(1.0 / dBlend); // normalize (0 <= z <= 1)
break;
case 6: // feathering
m_Weight.Set_Scaling(m_Weight.Get_Cellsize());
break;
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CWASP_MAP_Import::On_Execute(void)
{
int n, Method, nLength;
double z, dz, zMin, rLeft, rRight;
FILE *Stream;
TSG_Point p, pu[2], pm[2];
CSG_String fName, sLine;
CSG_Shape *pLine;
CSG_Shapes *pLines;
//-----------------------------------------------------
pLines = Parameters("SHAPES") ->asShapes();
fName = Parameters("FILE") ->asString();
Method = Parameters("METHOD") ->asInt();
//-----------------------------------------------------
if( (Stream = fopen(fName.b_str(), "r")) != NULL )
{
fseek(Stream, 0, SEEK_END);
nLength = ftell(Stream);
fseek(Stream, 0, SEEK_SET);
pLines->Create(SHAPE_TYPE_Line, SG_File_Get_Name(fName, false));
switch( Method )
{
case 0: // elevation
pLines->Add_Field("Z" , SG_DATATYPE_Double);
break;
case 1: // roughness
pLines->Add_Field("RLEFT" , SG_DATATYPE_Double);
pLines->Add_Field("RRIGHT" , SG_DATATYPE_Double);
break;
case 2: // elevation and roughness
pLines->Add_Field("Z" , SG_DATATYPE_Double);
pLines->Add_Field("RLEFT" , SG_DATATYPE_Double);
pLines->Add_Field("RRIGHT" , SG_DATATYPE_Double);
break;
}
// 1) Text string identifying the terrain map: + ...
SG_Read_Line(Stream, sLine);
// 2) Fixed point #1 in user and metric [m] coordinates:
// X1(user) Y1(user) X1(metric) Y1(metric)
fscanf(Stream, "%lf %lf %lf %lf", &pu[0].x, &pu[0].y, &pm[0].x, &pm[0].y);
// 3) Fixed point #2 in user and metric [m] coordinates:
// X2(user) Y2(user) X2(metric) Y2(metric)
fscanf(Stream, "%lf %lf %lf %lf", &pu[1].x, &pu[1].y, &pm[1].x, &pm[1].y);
// 4) Scaling factor and offset for height scale (Z):
// Zmetric = {scaling factor}(Zuser + {offset})
fscanf(Stream, "%lf %lf", &dz, &zMin);
while( !feof(Stream) && Set_Progress(ftell(Stream), nLength) )
{
pLine = NULL;
switch( Method )
{
case 0: // elevation
// 5a) Height contour: elevation (Z) and number of points (n) in line:
// Z n
fscanf(Stream, "%lf %d", &z, &n);
if( !feof(Stream) && n > 1 )
{
pLine = pLines->Add_Shape();
pLine->Set_Value(0, zMin + dz * z);
}
break;
case 1: // roughness
// 5b) Roughness change line:
// roughness lengths to the left (z0l) and right (z0r) side of the line,
// respectively, and number of points:
// z0l z0r n
fscanf(Stream, "%lf %lf %d", &rLeft, &rRight, &n);
if( !feof(Stream) && n > 1 )
{
pLine = pLines->Add_Shape();
pLine->Set_Value(0, rLeft);
pLine->Set_Value(1, rRight);
}
break;
case 2: // elevation and roughness
// 5c) Roughness and contour line:
// roughness lengths to the left and right of the line,
// respectively, elevation and number of points:
// z0l z0r Z n
fscanf(Stream, "%lf %lf %lf %d", &rLeft, &rRight, &z, &n);
if( !feof(Stream) && n > 1 )
{
pLine = pLines->Add_Shape();
pLine->Set_Value(0, zMin + dz * z);
pLine->Set_Value(1, rLeft);
pLine->Set_Value(2, rRight);
}
break;
}
// 6–) Cartesian coordinates (X, Y) of line described in 5a, 5b or 5c:
// X1 Y1 [... Xn Yn]
// Xn+1 Yn+1
// ... where [] embrace optional numbers and n is > 0
for(int i=0; i<n && !feof(Stream) && Process_Get_Okay(false); i++)
{
fscanf(Stream, "%lf %lf", &p.x, &p.y);
pLine->Add_Point(p);
}
}
fclose(Stream);
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 );
}
void Ctest_stream_power_model::streampower()
{
FILE *fp1;
float deltah,time,max;
int printinterval,idum,i,j,t,step;
fp1=fopen(fname,"w");
idum=-678;
//U=1; /* m/kyr */
//K=0.05; /* kyr^-1 */
printinterval=duration;
deltax=200.0; /* m */
thresh=0.58*deltax; /* 30 deg */
timestep=1; /* kyr */
//duration=100;
setupgridneighbors();
topo=matrix(1,lattice_size_x,1,lattice_size_y);
topo2=matrix(1,lattice_size_x,1,lattice_size_y);
topoold=matrix(1,lattice_size_x,1,lattice_size_y);
slope=matrix(1,lattice_size_x,1,lattice_size_y);
flow=matrix(1,lattice_size_x,1,lattice_size_y);
flow1=matrix(1,lattice_size_x,1,lattice_size_y);
flow2=matrix(1,lattice_size_x,1,lattice_size_y);
flow3=matrix(1,lattice_size_x,1,lattice_size_y);
flow4=matrix(1,lattice_size_x,1,lattice_size_y);
flow5=matrix(1,lattice_size_x,1,lattice_size_y);
flow6=matrix(1,lattice_size_x,1,lattice_size_y);
flow7=matrix(1,lattice_size_x,1,lattice_size_y);
flow8=matrix(1,lattice_size_x,1,lattice_size_y);
topovec=vector(1,lattice_size_x*lattice_size_y);
topovecind=ivector(1,lattice_size_x*lattice_size_y);
// was <=
for (i=1;i<lattice_size_x;i++)
{
// was <=
for (j=1;j<lattice_size_y;j++)
{
topo[i][j] = InputGrid->asFloat(i, j);
topo[i][j]=0.5*gasdev(&idum);
topoold[i][j]=topo[i][j];
flow[i][j]=1;
}
}
/*construct diffusional landscape for initial flow routing */
for (step=1;step<=10;step++)
{hillslopediffusioninit();
for (i=2;i<=lattice_size_x-1;i++)
for (j=2;j<=lattice_size_y-1;j++)
{topo[i][j]+=0.1;
topoold[i][j]+=0.1;}}
time=0;
while (time<duration && Process_Get_Okay(true))
{
/*perform landsliding*/
for (j=1;j<=lattice_size_y;j++)
for (i=1;i<=lattice_size_x;i++)
topovec[(j-1)*lattice_size_x+i]=topo[i][j];
indexx(lattice_size_x*lattice_size_y,topovec,topovecind);
t=0;
while (t<lattice_size_x*lattice_size_y)
{t++;
i=(topovecind[t])%lattice_size_x;
if (i==0) i=lattice_size_x;
j=(topovecind[t])/lattice_size_x+1;
if (i==lattice_size_x) j--;
avalanche(i,j);}
for (j=1;j<=lattice_size_y;j++)
for (i=1;i<=lattice_size_x;i++)
topoold[i][j]=topo[i][j];
for (j=1;j<=lattice_size_y;j++)
for (i=1;i<=lattice_size_x;i++)
fillinpitsandflats(i,j);
for (j=1;j<=lattice_size_y;j++)
for (i=1;i<=lattice_size_x;i++)
{flow[i][j]=1;
topovec[(j-1)*lattice_size_x+i]=topo[i][j];}
indexx(lattice_size_x*lattice_size_y,topovec,topovecind);
t=lattice_size_x*lattice_size_y+1;
while (t>1)
{t--;
i=(topovecind[t])%lattice_size_x;
if (i==0) i=lattice_size_x;
j=(topovecind[t])/lattice_size_x+1;
if (i==lattice_size_x) j--;
mfdflowroute(i,j);}
for (i=2;i<=lattice_size_x-1;i++)
for (j=2;j<=lattice_size_y-1;j++)
{topo[i][j]+=U*timestep;
topoold[i][j]+=U*timestep;}
/*perform upwind erosion*/
max=0;
// Potential parallel
for (i=2;i<=lattice_size_x-1;i++)
for (j=2;j<=lattice_size_y-1;j++)
{calculatealongchannelslope(i,j);
deltah=timestep*K*sqrt(flow[i][j])*deltax*slope[i][j];
topo[i][j]-=deltah;
if (topo[i][j]<0) topo[i][j]=0;
if (K*sqrt(flow[i][j])*deltax>max) max=K*sqrt(flow[i][j])*deltax;}
time+=timestep;
if (max>0.3*deltax/timestep)
{time-=timestep;
timestep/=2.0;
for (i=2;i<=lattice_size_x-1;i++)
for (j=2;j<=lattice_size_y-1;j++)
topo[i][j]=topoold[i][j]-U*timestep;}
else
{if (max<0.03*deltax/timestep) timestep*=1.2;
for (j=1;j<=lattice_size_y;j++)
for (i=1;i<=lattice_size_x;i++)
topoold[i][j]=topo[i][j];}
if ((int)time == printinterval )
{
printinterval+=printinterval;
// This was <=
for (i=1;i<lattice_size_x;i++)
{
// This was <=
for (j=1;j<lattice_size_y;j++)
{
// NOTE: Output grid size is incorrect, needs to account for 1 cell boundary
OutputGrid->Set_Value(i, j, topo[i][j]);
//fprintf(fp1,"%f\n",topo[i][j]);
}
}
}
}
}
//---------------------------------------------------------
bool CPolygonStatisticsFromPoints::On_Execute(void)
{
//-----------------------------------------------------
bool bSum = Parameters("SUM")->asBool();
bool bAvg = Parameters("AVG")->asBool();
bool bVar = Parameters("VAR")->asBool();
bool bDev = Parameters("DEV")->asBool();
bool bMin = Parameters("MIN")->asBool();
bool bMax = Parameters("MAX")->asBool();
bool bNum = Parameters("NUM")->asBool();
if( !bSum && !bAvg && !bVar && !bDev && !bMin && !bMax && !bNum )
{
Error_Set(_TL("no target variable in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Table_Fields *pFields = Parameters("FIELDS")->asTableFields();
if( pFields->Get_Count() <= 0 )
{
Error_Set(_TL("no attributes in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Shapes *pPoints = Parameters("POINTS" )->asShapes();
CSG_Shapes *pPolygons = Parameters("POLYGONS")->asShapes();
if( pPolygons->Get_Count() <= 0 || pPoints->Get_Count() <= 0 )
{
Error_Set(_TL("no records in input data"));
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();
}
//-----------------------------------------------------
int i, n, Offset = pPolygons->Get_Field_Count();
for(i=0; i<pFields->Get_Count(); i++)
{
CSG_String sName = pPoints->Get_Field_Name(pFields->Get_Index(i));
if( bSum ) { pPolygons->Add_Field(Get_Field_Name("SUM", sName), SG_DATATYPE_Double); }
if( bAvg ) { pPolygons->Add_Field(Get_Field_Name("AVG", sName), SG_DATATYPE_Double); }
if( bVar ) { pPolygons->Add_Field(Get_Field_Name("VAR", sName), SG_DATATYPE_Double); }
if( bDev ) { pPolygons->Add_Field(Get_Field_Name("DEV", sName), SG_DATATYPE_Double); }
if( bMin ) { pPolygons->Add_Field(Get_Field_Name("MIN", sName), SG_DATATYPE_Double); }
if( bMax ) { pPolygons->Add_Field(Get_Field_Name("MAX", sName), SG_DATATYPE_Double); }
if( bNum ) { pPolygons->Add_Field(Get_Field_Name("NUM", sName), SG_DATATYPE_Long ); }
}
//-----------------------------------------------------
CSG_Simple_Statistics *Statistics = new CSG_Simple_Statistics[pFields->Get_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<pFields->Get_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->Contains(pPoint->Get_Point(0)) )
{
for(i=0; i<pFields->Get_Count(); i++)
{
if( !pPoint->is_NoData(pFields->Get_Index(i)))
{
Statistics[i].Add_Value(pPoint->asDouble(pFields->Get_Index(i)));
}
}
}
}
//-------------------------------------------------
for(i=0, n=Offset; i<pFields->Get_Count(); i++)
{
if( Statistics[i].Get_Count() > 0 )
{
if( bSum ) { pPolygon->Set_Value (n++, Statistics[i].Get_Sum()); }
if( bAvg ) { pPolygon->Set_Value (n++, Statistics[i].Get_Mean()); }
if( bVar ) { pPolygon->Set_Value (n++, Statistics[i].Get_Variance()); }
if( bDev ) { pPolygon->Set_Value (n++, Statistics[i].Get_StdDev()); }
if( bMin ) { pPolygon->Set_Value (n++, Statistics[i].Get_Minimum()); }
if( bMax ) { pPolygon->Set_Value (n++, Statistics[i].Get_Maximum()); }
if( bNum ) { pPolygon->Set_Value (n++, (double)Statistics[i].Get_Count()); }
}
else
{
if( bSum ) { pPolygon->Set_NoData(n++); }
if( bAvg ) { pPolygon->Set_NoData(n++); }
if( bVar ) { pPolygon->Set_NoData(n++); }
if( bDev ) { pPolygon->Set_NoData(n++); }
if( bMin ) { pPolygon->Set_NoData(n++); }
if( bMax ) { pPolygon->Set_NoData(n++); }
if( bNum ) { pPolygon->Set_Value (n++, 0.0); }
}
}
}
//-----------------------------------------------------
delete[](Statistics);
DataObject_Update(pPolygons);
return( true );
}
//---------------------------------------------------------
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 CLine_Crossings::On_Execute(void)
{
CSG_Shapes *pLines_A = Parameters("LINES_A" )->asShapes();
CSG_Shapes *pLines_B = Parameters("LINES_B" )->asShapes();
CSG_Shapes *pCrossings = Parameters("CROSSINGS")->asShapes();
if( !pLines_A->is_Valid() || !pLines_B->is_Valid() || pLines_A->Get_Extent().Intersects(pLines_B->Get_Extent()) == INTERSECTION_None )
{
Error_Set(_TL("no intersection"));
return( false );
}
//--------------------------------------------------------
int Attributes = Parameters("ATTRIBUTES")->asInt();
pCrossings->Create(SHAPE_TYPE_Point, CSG_String::Format("%s [%s - %s]", _TL("Crossings"), pLines_A->Get_Name(), pLines_B->Get_Name()));
if( Attributes == 0 || Attributes == 2 )
{
pCrossings->Add_Field("ID_A", SG_DATATYPE_Int);
pCrossings->Add_Field("ID_B", SG_DATATYPE_Int);
}
if( Attributes == 1 || Attributes == 2 )
{
Add_Attributes(pCrossings, pLines_A);
Add_Attributes(pCrossings, pLines_B);
}
//--------------------------------------------------------
for(int aLine=0, iPair=0, nPairs=pLines_A->Get_Count()*pLines_B->Get_Count() && Process_Get_Okay(); aLine<pLines_A->Get_Count(); aLine++)
{
CSG_Shape_Line *pA = (CSG_Shape_Line *)pLines_A->Get_Shape(aLine);
for(int bLine=0; bLine<pLines_B->Get_Count() && Set_Progress(iPair++, nPairs); bLine++)
{
CSG_Shape_Line *pB = (CSG_Shape_Line *)pLines_B->Get_Shape(bLine);
if( pA->Intersects(pB) )
{
for(int aPart=0; aPart<pA->Get_Part_Count(); aPart++)
{
TSG_Point A[2]; A[1] = pA->Get_Point(0, aPart);
for(int aPoint=1; aPoint<pA->Get_Point_Count(aPart); aPoint++)
{
A[0] = A[1]; A[1] = pA->Get_Point(aPoint, aPart);
for(int bPart=0; bPart<pB->Get_Part_Count(); bPart++)
{
TSG_Point B[2], C; B[1] = pB->Get_Point(0, bPart);
for(int bPoint=1; bPoint<pB->Get_Point_Count(bPart); bPoint++)
{
B[0] = B[1]; B[1] = pB->Get_Point(bPoint, bPart);
if( SG_Get_Crossing(C, A[0], A[1], B[0], B[1]) )
{
Set_Crossing(C, pA, pB, pCrossings->Add_Shape(), Attributes);
}
}
}
}
}
}
}
}
//--------------------------------------------------------
return( pCrossings->Get_Count() > 0 );
}
