//---------------------------------------------------------
bool CShapes_Create_Empty::On_Execute(void)
{
TSG_Vertex_Type Vertex;
switch( Parameters("VERTEX")->asInt() )
{
default:
case 0: Vertex = SG_VERTEX_TYPE_XY; break;
case 1: Vertex = SG_VERTEX_TYPE_XYZ; break;
case 2: Vertex = SG_VERTEX_TYPE_XYZM; break;
}
//-----------------------------------------------------
CSG_Shapes *pShapes;
switch( Parameters("TYPE")->asInt() )
{
default: return( false );
case 0: pShapes = SG_Create_Shapes(SHAPE_TYPE_Point , Parameters("NAME")->asString(), NULL, Vertex); break;
case 1: pShapes = SG_Create_Shapes(SHAPE_TYPE_Points , Parameters("NAME")->asString(), NULL, Vertex); break;
case 2: pShapes = SG_Create_Shapes(SHAPE_TYPE_Line , Parameters("NAME")->asString(), NULL, Vertex); break;
case 3: pShapes = SG_Create_Shapes(SHAPE_TYPE_Polygon, Parameters("NAME")->asString(), NULL, Vertex); break;
}
//-----------------------------------------------------
int i, n;
TSG_Data_Type Type;
CSG_Parameters *pAttributes;
pAttributes = Parameters("FIELDS")->asParameters();
n = pAttributes->Get_Count() / 3;
for(i=0; i<n; i++)
{
switch( pAttributes->Get_Parameter(GET_TYPE(i))->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
pShapes->Add_Field(pAttributes->Get_Parameter(GET_NAME(i))->asString(), Type);
}
Parameters("SHAPES")->Set_Value(pShapes);
return( true );
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
CTable_Create_Empty::CTable_Create_Empty(void)
{
//-----------------------------------------------------
Set_Name (_TL("Create New Table"));
Set_Author (SG_T("O. Conrad (c) 2005"));
Set_Description (CSG_String::Format(_TW(
"Creates a new empty table.\n\n"
"Possible field types are:\n"
"- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
));
//-----------------------------------------------------
Parameters.Add_Table_Output(
NULL , "TABLE" , _TL("Table"),
_TL("")
);
Parameters.Add_String(
NULL , "NAME" , _TL("Name"),
_TL(""),
_TL("New Table")
);
Parameters.Add_Value(
NULL , "NFIELDS" , _TL("Number of Attributes"),
_TL(""),
PARAMETER_TYPE_Int , 2, 1, true
);
Parameters.Add_Parameters(
NULL , "FIELDS" , _TL("Attributes"),
_TL("")
);
//-----------------------------------------------------
CSG_Parameters *pAttributes = Parameters("FIELDS")->asParameters();
_Set_Field_Count(pAttributes, Parameters("NFIELDS")->asInt());
pAttributes->Get_Parameter(GET_NAME(0))->Set_Value(_TL("ID"));
pAttributes->Get_Parameter(GET_TYPE(0))->Set_Value(3);
}
//---------------------------------------------------------
int Scatter_Plot_On_Parameter_Changed(CSG_Parameter *pParameter, int Flags)
{
if( !pParameter || !pParameter->Get_Owner() )
{
return( -1 );
}
CSG_Parameters *pParameters = pParameter->Get_Owner();
if( Flags & PARAMETER_CHECK_ENABLE )
{
if( pParameter->Cmp_Identifier("CMP_WITH") )
{
pParameters->Get_Parameter("GRID")->Get_Parent()->Set_Enabled(pParameter->asInt() == 0);
pParameters->Set_Enabled("GRID" , pParameter->asInt() == 0);
pParameters->Set_Enabled("POINTS" , pParameter->asInt() == 1);
}
if( pParameter->Cmp_Identifier("REG_SHOW") )
{
pParameters->Set_Enabled("REG_FORMULA", pParameter->asBool());
pParameters->Set_Enabled("REG_COLOR" , pParameter->asBool());
pParameters->Set_Enabled("REG_SIZE" , pParameter->asBool());
pParameters->Set_Enabled("REG_INFO" , pParameter->asBool());
}
if( pParameter->Cmp_Identifier("DISPLAY") )
{
pParameters->Set_Enabled("DENSITY_RES", pParameter->asInt() == 1);
pParameters->Set_Enabled("DENSITY_PAL", pParameter->asInt() == 1);
pParameters->Set_Enabled("DENSITY_LEG", pParameter->asInt() == 1);
}
}
if( Flags & PARAMETER_CHECK_VALUES )
{
if( pParameter->Cmp_Identifier("CMP_WITH") )
{
// pParameters->Get_Parameter("OPTIONS")->asParameters()->
// Get_Parameter("DISPLAY")->Set_Value(pParameter->asInt() == 0 ? 1 : 0);
pParameters->Get_Parameter("DISPLAY")->Set_Value(pParameter->asInt() == 0 ? 1 : 0);
pParameters->Set_Enabled("DENSITY_RES", pParameter->asInt() == 0);
pParameters->Set_Enabled("DENSITY_PAL", pParameter->asInt() == 0);
pParameters->Set_Enabled("DENSITY_LEG", pParameter->asInt() == 0);
}
}
return( 0 );
}
//---------------------------------------------------------
bool CTable_PCA::Get_Fields(void)
{
CSG_Parameters *pFields = Parameters("FIELDS")->asParameters();
m_Features = (int *)SG_Calloc(pFields->Get_Count(), sizeof(int));
m_nFeatures = 0;
for(int iFeature=0; iFeature<pFields->Get_Count(); iFeature++)
{
if( pFields->Get_Parameter(iFeature)->asBool() )
{
CSG_String s(pFields->Get_Parameter(iFeature)->Get_Identifier());
m_Features[m_nFeatures++] = s.asInt();
}
}
return( m_nFeatures > 1 );
}
//---------------------------------------------------------
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 CTable_Create_Empty::On_Execute(void)
{
CSG_Table *pTable = SG_Create_Table();
pTable->Set_Name(Parameters("NAME")->asString());
//-----------------------------------------------------
int i, n;
TSG_Data_Type Type;
CSG_Parameters *pAttributes;
pAttributes = Parameters("FIELDS")->asParameters();
n = pAttributes->Get_Count() / 3;
for(i=0; i<n; i++)
{
switch( pAttributes->Get_Parameter(GET_TYPE(i))->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
pTable->Add_Field(pAttributes->Get_Parameter(GET_NAME(i))->asString(), Type);
}
Parameters("TABLE")->Set_Value(pTable);
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 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 );
}
//---------------------------------------------------------
CShapes_Create_Empty::CShapes_Create_Empty(void)
{
//-----------------------------------------------------
Set_Name (_TL("Create New Shapes Layer"));
Set_Author (SG_T("O. Conrad (c) 2008"));
Set_Description (CSG_String::Format(_TW(
"Creates a new empty shapes layer of given type, "
"which might be either point, multipoint, line or polygon.\n\n"
"Possible field types for the attributes table are:\n"
"- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
));
//-----------------------------------------------------
Parameters.Add_Shapes_Output(
NULL , "SHAPES" , _TL("Shapes"),
_TL("")
);
Parameters.Add_String(
NULL , "NAME" , _TL("Name"),
_TL(""),
_TL("New Shapes Layer")
);
Parameters.Add_Choice(
NULL , "TYPE" , _TL("Shape Type"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|"),
_TL("Point"),
_TL("Multipoint"),
_TL("Lines"),
_TL("Polygon")
)
);
Parameters.Add_Choice(
NULL , "VERTEX" , _TL("Vertex Type"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|"),
_TL("x, y"),
_TL("x, y, z"),
_TL("x, y, z, m")
)
);
Parameters.Add_Value(
NULL , "NFIELDS" , _TL("Number of Attributes"),
_TL(""),
PARAMETER_TYPE_Int , 2, 1, true
);
Parameters.Add_Parameters(
NULL , "FIELDS" , _TL("Attributes"),
_TL("")
);
//-----------------------------------------------------
CSG_Parameters *pAttributes = Parameters("FIELDS")->asParameters();
_Set_Field_Count(pAttributes, Parameters("NFIELDS")->asInt());
pAttributes->Get_Parameter(GET_NAME(0))->Set_Value(_TL("ID"));
pAttributes->Get_Parameter(GET_TYPE(0))->Set_Value(3);
}