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
void CSG_Doc_SVG::Draw_Polygon(CSG_Points &Points,
int Fill_Color,
int Line_Color,
double Line_Width)
{
if( Points.Get_Count() > 2 )
{
int i;
CSG_String sPoints;
CSG_String sWidth;
for (i = 0; i < Points.Get_Count(); i++)
{
sPoints.Append(SG_Get_String(Points.Get_X(i),2));
sPoints.Append(SG_T(","));
sPoints.Append(SG_Get_String(Points.Get_Y(i),2));
sPoints.Append(SG_T(" "));
}
m_sSVGCode.Append(SG_T("<polygon "));
_AddAttribute(SG_T("points"), sPoints);
sWidth.Append(SG_Get_String(Line_Width,2));
sWidth.Append(g_Unit);
_AddAttribute(SG_T("stroke-width"), sWidth);
_AddAttribute(SG_T("stroke"), _Get_SVGColor(Line_Color));
_AddAttribute(SG_T("fill"), _Get_SVGColor(Fill_Color));
m_sSVGCode.Append(SG_T("/>\n"));
}
}
void CSG_Doc_SVG::Draw_LinkedPolygon(CSG_Points &Points,
const SG_Char* Link,
int Fill_Color,
int Line_Color,
double Line_Width)
{
if( Points.Get_Count() > 2 )
{
int i;
CSG_String sPoints;
CSG_String sWidth;
CSG_String sLink;
for (i = 0; i < Points.Get_Count(); i++)
{
sPoints.Append(SG_Get_String(Points.Get_X(i),2));
sPoints.Append(SG_T(","));
sPoints.Append(SG_Get_String(Points.Get_Y(i),2));
sPoints.Append(SG_T(" "));
}
m_sSVGCode.Append(SG_T("<polygon "));
_AddAttribute(SG_T("points"), sPoints);
sWidth.Append(SG_Get_String(Line_Width,2));
sWidth.Append(g_Unit);
_AddAttribute(SG_T("stroke-width"), sWidth);
_AddAttribute(SG_T("stroke"), _Get_SVGColor(Line_Color));
_AddAttribute(SG_T("fill"), _Get_SVGColor(Fill_Color));
sLink = SG_T("window.open('");
sLink.Append(Link);
sLink.Append(SG_T("')"));
_AddAttribute(SG_T("onclick"), sLink);
m_sSVGCode.Append(SG_T("/>\n"));
}
}
//---------------------------------------------------------
void CActive_Attributes_Control::On_Field_Del(wxCommandEvent &event)
{
if( !g_pActive->Get_Active_Data_Item() || g_pActive->Get_Active_Data_Item()->Get_Type() != WKSP_ITEM_Grids ) { return; }
CSG_Grids *pGrids = ((CWKSP_Grids *)g_pActive->Get_Active_Data_Item())->Get_Grids();
//-----------------------------------------------------
int i;
CSG_Parameters P;
//-----------------------------------------------------
P.Set_Name(_TL("Delete Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_Value(NULL, SG_Get_String(i), m_pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=m_pTable->Get_Field_Count()-1; i>=0; i--)
{
if( P(SG_Get_String(i))->asBool() )
{
pGrids->Get_Attributes_Ptr()->Del_Field(i);
DeleteCols(i);
}
}
g_pData->Update(pGrids, NULL);
}
}
void CSG_Doc_SVG::Draw_Line(CSG_Points &Points,
double Width,
int Color)
{
int i;
CSG_String sPoints;
CSG_String sWidth;
for (i = 0; i < Points.Get_Count(); i++)
{
sPoints.Append(SG_Get_String(Points.Get_X(i),2));
sPoints.Append(SG_T(","));
sPoints.Append(SG_Get_String(Points.Get_Y(i),2));
sPoints.Append(SG_T(" "));
}
m_sSVGCode.Append(SG_T("<polyline "));
_AddAttribute(SG_T("points"), sPoints);
sWidth.Append(SG_Get_String(Width,2));
sWidth.Append(g_Unit);
_AddAttribute(SG_T("stroke-width"), sWidth);
_AddAttribute(SG_T("stroke"), _Get_SVGColor(Color));
_AddAttribute(SG_T("fill"), SG_T("none"));
m_sSVGCode.Append(SG_T("/>\n"));
}
//---------------------------------------------------------
void CVIEW_Table_Control::On_Field_Del(wxCommandEvent &event)
{
int i;
CSG_Parameters P;
//-----------------------------------------------------
P.Set_Name(_TL("Delete Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_Value(NULL, SG_Get_String(i, 0), m_pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=m_pTable->Get_Field_Count()-1; i>=0; i--)
{
if( P(SG_Get_String(i, 0))->asBool() )
{
m_pTable->Del_Field(i);
DeleteCols(i);
}
}
g_pData->Update(m_pTable, NULL);
}
}
void CSG_Doc_SVG::Open(int iWidth, int iHeight)
{
m_sSVGCode.Append(SVG_CODE_OPENING_1);
m_sSVGCode.Append(SG_Get_String(iWidth,0));
m_sSVGCode.Append(SG_T("\" height=\""));
m_sSVGCode.Append(SG_Get_String(iHeight,0));
m_sSVGCode.Append(SVG_CODE_OPENING_2);
m_iWidth = iWidth;
m_iHeight = iHeight;
}
void CSG_Doc_SVG::Draw_LinkedCircle(double x,
double y,
double Radius,
const SG_Char *Link,
int Fill_Color,
int Line_Color,
double Line_Width)
{
CSG_String sWidth;
CSG_String sLink;
m_sSVGCode.Append(SG_T("<circle "));
_AddAttribute(SG_T("cx"), x);
_AddAttribute(SG_T("cy"), y);
_AddAttribute(SG_T("r"), Radius);
sWidth.Append(SG_Get_String(Line_Width,2));
sWidth.Append(g_Unit);
_AddAttribute(SG_T("stroke-width"), sWidth);
_AddAttribute(SG_T("stroke"), _Get_SVGColor(Line_Color));
_AddAttribute(SG_T("fill"), _Get_SVGColor(Fill_Color));
sLink = SG_T("window.open('");
sLink.Append(Link);
sLink.Append(SG_T("')"));
_AddAttribute(SG_T("onclick"), sLink);
m_sSVGCode.Append(SG_T("/>\n"));
}
void CSG_Doc_SVG::_AddAttribute(const SG_Char *Attribute,
double dValue)
{
_AddAttribute(Attribute, SG_Get_String(dValue, 2));
}
//---------------------------------------------------------
void CActive_Attributes_Control::On_Field_Rename(wxCommandEvent &event)
{
if( !g_pActive->Get_Active_Data_Item() || g_pActive->Get_Active_Data_Item()->Get_Type() != WKSP_ITEM_Grids ) { return; }
CSG_Grids *pGrids = ((CWKSP_Grids *)g_pActive->Get_Active_Data_Item())->Get_Grids();
//-----------------------------------------------------
int i;
CSG_Parameters P;
P.Set_Name(_TL("Rename Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_String(NULL, SG_Get_String(i), m_pTable->Get_Field_Name(i), _TL(""), m_pTable->Get_Field_Name(i));
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
CSG_String s(P(i)->asString());
if( s.Length() > 0 && s.Cmp(m_pTable->Get_Field_Name(i)) )
{
pGrids->Get_Attributes_Ptr()->Set_Field_Name(i, s);
SetColLabelValue(i, s.c_str());
}
}
g_pData->Update(pGrids, NULL);
}
}
void CSG_Doc_SVG::Draw_Text(double x,
double y,
const SG_Char *Text,
int Color,
const SG_Char* Font,
double dSize,
TSG_SVG_Alignment iAlignment)
{
CSG_String sAlignments[] = {SG_T(""), SG_T("middle"), SG_T("end")};
CSG_String sSize;
sSize.Append(SG_Get_String(dSize,2));
sSize.Append(g_Unit);
m_sSVGCode.Append(SG_T("<text "));
_AddAttribute(SG_T("x"), x);
_AddAttribute(SG_T("y"), y);
_AddAttribute(SG_T("font-family"), Font);
_AddAttribute(SG_T("fill"), _Get_SVGColor(Color));
_AddAttribute(SG_T("font-size"), sSize);
_AddAttribute(SG_T("text-anchor"), sAlignments[iAlignment]);
m_sSVGCode.Append(SG_T(">\n"));
m_sSVGCode.Append(Text);
m_sSVGCode.Append(SG_T("</text>"));
}
//---------------------------------------------------------
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 );
}
CSG_String CSG_Doc_SVG::_Get_SVGColor(int iColor)
{
CSG_String s;
if (iColor == SG_COLOR_NONE)
{
return SG_T("none");
}
else if (iColor == SG_COLOR_RANDOM)
{
s.Append(SG_T("rgb("));
s.Append(SG_Get_String((int)(255.0 * (double)rand() / (double)RAND_MAX),0));
s.Append(SG_T(","));
s.Append(SG_Get_String((int)(255.0 * (double)rand() / (double)RAND_MAX),0));
s.Append(SG_T(","));
s.Append(SG_Get_String((int)(255.0 * (double)rand() / (double)RAND_MAX),0));
s.Append(SG_T(")"));
return s;
}
else
{
s.Append(SG_T("rgb("));
s.Append(SG_Get_String(SG_GET_R(iColor),0));
s.Append(SG_T(","));
s.Append(SG_Get_String(SG_GET_G(iColor),0));
s.Append(SG_T(","));
s.Append(SG_Get_String(SG_GET_B(iColor),0));
s.Append(SG_T(")"));
return s;
}
}
//---------------------------------------------------------
bool DLG_Table_Fields(const wxString &Caption, CSG_Parameter_Table_Fields *pFields)
{
CSG_Table *pTable = pFields->Get_Table();
if( pTable )
{
int i;
CSG_Parameters P;
for(i=0; i<pTable->Get_Field_Count(); i++)
{
P.Add_Value(NULL, SG_Get_String(i), pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
for(i=0; i<pFields->Get_Count(); i++)
{
CSG_Parameter *pParameter = P(pFields->Get_Index(i));
if( pParameter )
{
pParameter->Set_Value(true);
}
}
if( DLG_Parameters(&P) )
{
CSG_String s;
for(i=0; i<pTable->Get_Field_Count(); i++)
{
if( P(i)->asBool() )
{
s += CSG_String::Format(s.Length() ? SG_T(",%d") : SG_T("%d"), i);
}
}
pFields->Set_Value(s);
return( true );
}
}
return( false );
}
//---------------------------------------------------------
int CGW_Multi_Regression::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter)
{
if( m_Grid_Target.On_User_Changed(pParameters, pParameter) )
{
return( true );
}
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("POINTS")) )
{
CSG_Shapes *pPoints = pParameters->Get_Parameter("POINTS") ->asShapes();
CSG_Parameters *pAttributes = pParameters->Get_Parameter("PREDICTORS") ->asParameters();
pAttributes->Destroy();
pAttributes->Set_Name(_TL("Predictors"));
for(int i=0; pPoints && i<pPoints->Get_Field_Count(); i++)
{
switch( pPoints->Get_Field_Type(i) )
{
default: // not numeric
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:
pAttributes->Add_Value(
NULL, SG_Get_String(i, 0), pPoints->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false
);
break;
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
CSG_String CGCS_Graticule::Get_Degree(double Value, int Precision)
{
if( Precision == DEG_PREC_DEG )
{
return( SG_Get_String(Value, -12) + "\xb0" );
}
SG_Char c;
int d, h;
double s;
CSG_String String;
if( Value < 0.0 )
{
Value = -Value;
c = SG_T('-');
}
else
{
c = SG_T('+');
}
Value = fmod(Value, 360.0);
d = (int)Value;
Value = 60.0 * (Value - d);
h = (int)Value;
Value = 60.0 * (Value - h);
s = Value;
if( s > 0.0 || Precision == DEG_PREC_FULL )
{
String.Printf(SG_T("%c%d\xb0%02d'%02.*f''"), c, d, h, SG_Get_Significant_Decimals(s), s);
}
else if( h > 0 || Precision == DEG_PREC_MIN )
{
String.Printf(SG_T("%c%d\xb0%02d'" ), c, d, h);
}
else
{
String.Printf(SG_T("%c%d\xb0" ), c, d);
}
return( String );
}
void CSG_Doc_SVG::Draw_Line(double xa,
double ya,
double xb,
double yb,
double Width,
int Color)
{
CSG_String sWidth;
m_sSVGCode.Append(SG_T("<line "));
_AddAttribute(SG_T("x1"), xa);
_AddAttribute(SG_T("x2"), xb);
_AddAttribute(SG_T("y1"), ya);
_AddAttribute(SG_T("y2"), yb);
sWidth.Append(SG_Get_String(Width,2));
sWidth.Append(g_Unit);
_AddAttribute(SG_T("stroke-width"), sWidth); _AddAttribute(SG_T("stroke"), _Get_SVGColor(Color));
m_sSVGCode.Append(SG_T("/>\n"));
}
void CSG_Doc_SVG::Draw_Circle(double x,
double y,
double Radius,
int Fill_Color,
int Line_Color,
double Line_Width)
{
CSG_String sWidth;
m_sSVGCode.Append(SG_T("<circle "));
_AddAttribute(SG_T("cx"), x);
_AddAttribute(SG_T("cy"), y);
_AddAttribute(SG_T("r"), Radius);
sWidth.Append(SG_Get_String(Line_Width,2));
sWidth.Append(g_Unit);
_AddAttribute(SG_T("stroke-width"), sWidth);
_AddAttribute(SG_T("stroke"), _Get_SVGColor(Line_Color));
_AddAttribute(SG_T("fill"), _Get_SVGColor(Fill_Color));
m_sSVGCode.Append(SG_T("/>\n"));
}
//---------------------------------------------------------
bool CGW_Multi_Regression::On_Execute(void)
{
int i;
//-----------------------------------------------------
m_pPoints = Parameters("POINTS") ->asShapes();
m_iDependent = Parameters("DEPENDENT") ->asInt();
m_Radius = Parameters("RANGE") ->asInt() == 0 ? Parameters("RADIUS") ->asDouble() : 0.0;
m_Mode = Parameters("MODE") ->asInt();
m_nPoints_Max = Parameters("NPOINTS") ->asInt() == 0 ? Parameters("MAXPOINTS")->asInt() : 0;
m_nPoints_Min = Parameters("MINPOINTS") ->asInt();
m_Weighting.Set_Parameters(Parameters("WEIGHTING")->asParameters());
//-----------------------------------------------------
if( !Get_Predictors() )
{
Finalize();
return( false );
}
if( (m_nPoints_Max > 0 || m_Radius > 0.0) && !m_Search.Create(m_pPoints, -1) )
{
Finalize();
return( false );
}
//-----------------------------------------------------
m_pQuality = NULL;
m_pIntercept = NULL;
m_pSlopes = (CSG_Grid **)SG_Calloc(m_nPredictors, sizeof(CSG_Grid *));
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pQuality = m_Grid_Target.Get_User(SG_T("QUALITY" ));
m_pIntercept = m_Grid_Target.Get_User(SG_T("INTERCEPT"));
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i] = m_Grid_Target.Get_User(SG_Get_String(i, 0));
}
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pQuality = m_Grid_Target.Get_Grid(SG_T("QUALITY" ));
m_pIntercept = m_Grid_Target.Get_Grid(SG_T("INTERCEPT"));
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i] = m_Grid_Target.Get_Grid(SG_Get_String(i, 0));
}
}
break;
}
if( m_pQuality == NULL )
{
Finalize();
return( false );
}
m_pQuality ->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Quality")));
m_pIntercept->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Intercept")));
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i]->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), m_pPoints->Get_Field_Name(m_iPredictor[i])));
}
//-----------------------------------------------------
int nPoints_Max = m_nPoints_Max > 0 ? m_nPoints_Max : m_pPoints->Get_Count();
m_y.Create(1 + m_nPredictors, nPoints_Max);
m_z.Create(nPoints_Max);
m_w.Create(nPoints_Max);
//-----------------------------------------------------
for(int y=0; y<m_pIntercept->Get_NY() && Set_Progress(y, m_pIntercept->Get_NY()); y++)
{
for(int x=0; x<m_pIntercept->Get_NX(); x++)
{
if( !Get_Regression(x, y) )
{
m_pQuality ->Set_NoData(x, y);
m_pIntercept->Set_NoData(x, y);
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i]->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
Finalize();
return( true );
}
//---------------------------------------------------------
bool CPointcloud_To_Text_File::On_Execute(void)
{
CSG_PointCloud *pPoints;
CSG_String fileName;
CSG_File *pTabStream = NULL;
bool bWriteHeader;
CSG_String fieldSep;
CSG_Parameters P;
CSG_Parameter *pNode;
CSG_String s;
std::vector<int> vCol, vPrecision;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asPointCloud();
fileName = Parameters("FILE") ->asString();
bWriteHeader = Parameters("WRITE_HEADER")->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = "\t"; break;
case 1: fieldSep = " "; break;
case 2: fieldSep = ","; break;
}
if( fileName.Length() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide an output file name!"));
return( false );
}
if (SG_UI_Get_Window_Main())
{
P.Set_Name(_TL("Check the fields to export"));
for(int iField=0; iField<pPoints->Get_Field_Count(); iField++)
{
s.Printf(SG_T("NODE_%03d") , iField + 1);
pNode = P.Add_Node(NULL, s, CSG_String::Format(_TL("%d. %s"), iField + 1, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_Value(pNode, s, CSG_String::Format(SG_T("%s"), pPoints->Get_Field_Name(iField)), _TL(""), PARAMETER_TYPE_Bool, false);
s.Printf(SG_T("PRECISION_%03d"), iField);
P.Add_Value(pNode, s, _TL("Decimal Precision"), _TL(""), PARAMETER_TYPE_Int, 2.0, 0.0, true);
}
//-----------------------------------------------------
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
vCol.clear();
vPrecision.clear();
for(int iField=0; iField<pPoints->Get_Field_Count(); iField++)
{
if( P(CSG_String::Format(SG_T("FIELD_%03d" ), iField).c_str())->asBool() )
{
vCol.push_back(iField);
vPrecision.push_back(P(CSG_String::Format(SG_T("PRECISION_%03d" ), iField).c_str())->asInt());
}
}
}
else
return( false );
}
else // CMD
{
CSG_String sFields, sPrecision;
CSG_String token;
int iValue;
sFields = Parameters("FIELDS")->asString();
sPrecision = Parameters("PRECISIONS")->asString();
CSG_String_Tokenizer tkz_fields(sFields, ";", SG_TOKEN_STRTOK);
while( tkz_fields.Has_More_Tokens() )
{
token = tkz_fields.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
iValue -= 1;
if( iValue < 0 || iValue > pPoints->Get_Field_Count() - 1 )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: field index out of range"));
return( false );
}
else
vCol.push_back(iValue);
}
CSG_String_Tokenizer tkz_precisons(sPrecision.c_str(), ";", SG_TOKEN_STRTOK);
while( tkz_precisons.Has_More_Tokens() )
{
token = tkz_precisons.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
vPrecision.push_back(iValue);
}
}
if( vCol.size() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide at least one column to export!"));
return( false );
}
if( vCol.size() != vPrecision.size() )
{
SG_UI_Msg_Add_Error(_TL("Number of fields and precisions must be equal!"));
return( false );
}
//-----------------------------------------------------
pTabStream = new CSG_File();
if( !pTabStream->Open(fileName, SG_FILE_W, false) )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open output file %s!"), fileName.c_str()));
delete (pTabStream);
return (false);
}
if( bWriteHeader )
{
CSG_String sHeader;
for(size_t i=0; i<vCol.size(); i++)
{
sHeader += CSG_String::Format(SG_T("%s"), pPoints->Get_Field_Name(vCol.at(i)));
if( i < vCol.size()-1 )
sHeader += fieldSep.c_str();
}
sHeader += SG_T("\n");
pTabStream->Write(sHeader);
}
for(int iPoint=0; iPoint<pPoints->Get_Count() && Set_Progress(iPoint, pPoints->Get_Count()); iPoint++)
{
CSG_String sLine;
for(size_t i=0; i<vCol.size(); i++)
{
switch (pPoints->Get_Field_Type(vCol.at(i)))
{
case SG_DATATYPE_Double:
case SG_DATATYPE_Float:
sLine += SG_Get_String(pPoints->Get_Value(iPoint, vCol.at(i)), vPrecision.at(i), false);
break;
default:
sLine += CSG_String::Format(SG_T("%d"), (int)pPoints->Get_Value(iPoint, vCol.at(i)));
break;
}
if( i < vCol.size()-1 )
sLine += fieldSep.c_str();
}
sLine += SG_T("\n");
pTabStream->Write(sLine);
}
pTabStream->Close();
delete (pTabStream);
return( true );
}
CSG_MetaData * CSG_MetaData::Ins_Child(const CSG_String &Name, double Content, int Position)
{
return( Ins_Child(Name, SG_Get_String(Content, -16), Position) );
}
void CSG_Doc_SVG::_AddAttribute(const SG_Char *Attribute,
int iValue)
{
_AddAttribute(Attribute, SG_Get_String(iValue, 0));
}
//---------------------------------------------------------
void CActive_Attributes_Control::On_Field_Type(wxCommandEvent &event)
{
if( !g_pActive->Get_Active_Data_Item() || g_pActive->Get_Active_Data_Item()->Get_Type() != WKSP_ITEM_Grids ) { return; }
CSG_Grids *pGrids = ((CWKSP_Grids *)g_pActive->Get_Active_Data_Item())->Get_Grids();
//-----------------------------------------------------
int i, *Types = new int[m_pTable->Get_Field_Count()];
CSG_Parameters P;
P.Set_Name(_TL("Change Field Type"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
switch( m_pTable->Get_Field_Type(i) )
{
default:
case SG_DATATYPE_String: Types[i] = 0; break;
case SG_DATATYPE_Date : Types[i] = 1; break;
case SG_DATATYPE_Color : Types[i] = 2; break;
case SG_DATATYPE_Byte : Types[i] = 3; break;
case SG_DATATYPE_Char : Types[i] = 4; break;
case SG_DATATYPE_Word : Types[i] = 5; break;
case SG_DATATYPE_Short : Types[i] = 6; break;
case SG_DATATYPE_DWord : Types[i] = 7; break;
case SG_DATATYPE_Int : Types[i] = 8; break;
case SG_DATATYPE_ULong : Types[i] = 9; break;
case SG_DATATYPE_Long : Types[i] = 10; break;
case SG_DATATYPE_Float : Types[i] = 11; break;
case SG_DATATYPE_Double: Types[i] = 12; break;
case SG_DATATYPE_Binary: Types[i] = 13; break;
}
P.Add_Choice("", SG_Get_String(i), m_pTable->Get_Field_Name(i), _TL(""),
CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|",
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()
), Types[i]
);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
bool bChanged = false;
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
TSG_Data_Type Type;
switch( P(i)->asInt() )
{
default: 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;
}
if( Type != m_pTable->Get_Field_Type(i) )
{
pGrids->Get_Attributes_Ptr()->Set_Field_Type(i, Type);
bChanged = true;
}
}
if( bChanged )
{
Update_Table();
g_pData->Update(pGrids, NULL);
}
}
}
//---------------------------------------------------------
bool CResection::On_Execute(void)
{
CSG_PointCloud *pPoints; // Input Point Cloud
CSG_String fileName;
CSG_File *pTabStream = NULL;
int n = 6; // Number of unknowns
CSG_Vector center(3);
CSG_Vector target(3);
double c = Parameters("F") ->asDouble(); // Focal Length (mm)
double pixWmm = Parameters("W") ->asDouble() / 1000;// Pixel Width (mm)
double ppOffsetX = Parameters("ppX") ->asDouble(); // Principal Point Offset X (pixels)
double ppOffsetY = Parameters("ppY") ->asDouble(); // Principal Point Offset Y (pixels)
pPoints = Parameters("POINTS") ->asPointCloud();
fileName = Parameters("OUTPUT FILE") ->asString();
center[0] = Parameters("Xc") ->asDouble();
center[1] = Parameters("Yc") ->asDouble();
center[2] = Parameters("Zc") ->asDouble();
target[0] = Parameters("Xt") ->asDouble();
target[1] = Parameters("Yt") ->asDouble();
target[2] = Parameters("Zt") ->asDouble();
int pointCount = pPoints->Get_Point_Count();
bool estPPOffsets = false;
if ( Parameters("EST_OFFSETS")->asBool() ) {
estPPOffsets = true;
n = 8; // Increase number of unknowns by 2
}
bool applyDistortions = false;
CSG_Vector K(3);
if ( Parameters("GIVE_DISTORTIONS")->asBool() ) {
applyDistortions = true;
K[0] = Parameters("K1") ->asDouble();
K[1] = Parameters("K2") ->asDouble();
K[2] = Parameters("K3") ->asDouble();
}
double dxapp = center [0] - target [0];
double dyapp = center [1] - target [1];
double dzapp = center [2] - target [2];
double h_d = sqrt (dxapp * dxapp + dyapp * dyapp + dzapp * dzapp); // Distance between Proj. Center & Target (m)
double h_dmm = h_d * 1000; // Convert to mm
if( fileName.Length() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide an output file name!"));
return( false );
}
pTabStream = new CSG_File();
if( !pTabStream->Open(fileName, SG_FILE_W, false) )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open output file %s!"), fileName.c_str()));
delete (pTabStream);
return (false);
}
CSG_Vector rotns = methods::calcRotations(center,target); // Approx. rotations omega, kappa, alpha
CSG_String msg = "********* Initial Approximate Values *********";
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Rotation Angles:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Omega:\t") + SG_Get_String(rotns[0],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Kappa:\t") + SG_Get_String(rotns[1],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Alpha:\t") + SG_Get_String(rotns[2],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Projection Center:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Xc:\t") + SG_Get_String(center[0],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Yc:\t") + SG_Get_String(center[1],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Zc:\t") + SG_Get_String(center[2],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
if (estPPOffsets) {
msg = SG_T("Principal Point Offsets:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppX:\t") + SG_Get_String(ppOffsetX,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppY:\t") + SG_Get_String(ppOffsetY,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
}
double itrNo = 0;
CSG_Matrix invN;
while (true) { // Begin Iterations
itrNo++;
double omega = rotns[0];
double kappa = rotns[1];
double alpha = rotns[2];
CSG_Matrix R = methods::calcRotnMatrix(rotns); // Rotation Matrix from approximate values
CSG_Matrix E(3,3); // [w1;w2;w3] = E * [dw;dk;da]
E[0][0] = -1;
E[0][1] = E[1][0] = E[2][0] = 0;
E[0][2] = sin(kappa);
E[1][1] = -cos(omega);
E[1][2] = -sin(omega) * cos(kappa);
E[2][1] = sin(omega);
E[2][2] = -cos(omega) * cos(kappa);
CSG_Matrix N(n,n); // Transpose(Design Matrix) * I * Design Matrix
CSG_Vector ATL(n); // Transpose(Design Matrix) * I * Shortened obs. vector
double SS = 0;
double sigma_naught = 0;
for (int i = 0; i < pointCount; i++) {
CSG_Vector pqs(3); // Approx. pi, qi, si
for (int j = 0; j < 3; j++) {
pqs[j] = R[j][0] * (pPoints->Get_X(i) - center[0]) +
R[j][1] * (pPoints->Get_Y(i) - center[1]) +
R[j][2] * (pPoints->Get_Z(i) - center[2]);
}
double p_i = pqs[0];
double q_i = pqs[1];
double s_i = pqs[2];
double dR = 0;
// Undistorted
double x_u = c * p_i / q_i;
double y_u = c * s_i / q_i;
double c_hat = c;
if (applyDistortions) {
double r2 = x_u * x_u + y_u * y_u;
dR = K[0] * r2 + K[1] * r2 * r2 + K[2] * r2 * r2 * r2;
c_hat = c * (1 - dR);
}
// Approx. image coordinates (with distortions)
double x_i = (1 - dR) * x_u + ppOffsetX * pixWmm;
double z_i = (1 - dR) * y_u + ppOffsetY * pixWmm;
// Shortened obervation vector: dxi & dzi
double dx_i = pPoints->Get_Attribute(i,0) * pixWmm - x_i;
double dz_i = pPoints->Get_Attribute(i,1) * pixWmm - z_i;
SS += pow(dx_i,2) + pow(dz_i,2);
/*
x_i, z_i in [mm]
p_i,q_i,s_i in [m]
h_d in [m]
c, c_hat in [mm]
h_dmm in [mm]
*/
CSG_Matrix L(3,2); // CSG_Matrix takes columns first and rows second
CSG_Matrix V(3,3);
CSG_Matrix LR(3,2);
CSG_Matrix LVE(3,2);
L[0][0] = L[1][2] = c_hat / (1000 * q_i);
L[0][2] = L[1][0] = 0;
L[0][1] = -x_u * (1 - dR) / (1000 * q_i);
L[1][1] = -y_u * (1 - dR) / (1000 * q_i);
V[0][0] = V[1][1] = V[2][2] = 0;
V[0][1] = s_i / h_d;
V[0][2] = -q_i / h_d;
V[1][0] = -s_i / h_d;
V[1][2] = p_i / h_d;
V[2][0] = q_i / h_d;
V[2][1] = -p_i / h_d;
LVE = ( L * V ) * E;
LR = L * R;
// Design Matrix (J)
CSG_Matrix design(n,2);
for(int j = 0; j < 2; j++) {
for(int k = 0; k < 3; k++) {
design[j][k] = LVE[j][k];
design[j][k+3] = -LR[j][k];
}
}
if ( estPPOffsets ) {
design[0][6] = design[1][7] = 1.0;
}
// Build Normal Matrix
for(int j = 0; j < n; j++) {
for(int k = 0; k < n; k++) {
N[j][k] += (design[0][j] * design[0][k] + design[1][j] * design[1][k]);
}
}
// Build Tranpose (J) * I * (Shortened obs. vector)
for (int m=0; m < n; m++) {
ATL[m] += design[0][m] * dx_i + design[1][m] * dz_i;
}
L.Destroy();
V.Destroy();
LR.Destroy();
LVE.Destroy();
pqs.Destroy();
design.Destroy();
} // end looping over observations
// Eigen values and Eigen Vectors
CSG_Vector eigenVals(n);
CSG_Matrix eigenVecs(n,n);
SG_Matrix_Eigen_Reduction(N, eigenVecs, eigenVals, true);
// One of the Eigen Values is 0
if (std::any_of(eigenVals.cbegin(),
eigenVals.cend(),
[] (double i) { return i == 0; })) {
msg = "The Normal Matrix has a rank defect. Please measure more points.";
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
break;
}
double mx = *std::max_element(eigenVals.cbegin(), eigenVals.cend());
double mn = *std::min_element(eigenVals.cbegin(), eigenVals.cend());
// Ratio of Smallest to the Biggest Eigen value is too small
if ((mn / mx) < pow(10,-12.0)) {
msg = SG_T("Condition of the Matrix of Normal Equations:\t") + CSG_String::Format(SG_T(" %13.5e"), mn/mx);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = "The Normal Matrix is weakly conditioned. Please measure more points.";
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
break;
}
// Calculate the adjustments
double absMax = 0;
invN = N.Get_Inverse();
CSG_Vector est_param_incs = invN * ATL;
for (int i = 0; i < n; i++) {
if (abs(est_param_incs[i]) > absMax) {
absMax = abs(est_param_incs[i]);
}
}
if (absMax < thresh) {
msg = "Solution has converged.";
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
break;
}
for (int a = 0; a < 3; a++) {
rotns[a] += est_param_incs[a] / h_dmm; // New Approx. rotations omega, kappa, alpha
center[a] += est_param_incs[a+3] / 1000; // New Approx. Projection Center
}
if ( estPPOffsets ) {
ppOffsetX += (est_param_incs[6] / pixWmm); // New Approx. Principal Point
ppOffsetY += (est_param_incs[7] / pixWmm);
}
sigma_naught = sqrt(SS / (2 * pointCount - n));
// Writing To Output File & SAGA Console
msg = "********* Iteration: " + SG_Get_String(itrNo,0,false) + " *********";
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = "Sum of Squared Residuals:\t" + SG_Get_String(SS,5,false);
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = "Sigma Naught:\t" + SG_Get_String(sigma_naught,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Condition of the Matrix of Normal Equations:\t") + CSG_String::Format(SG_T(" %13.5e"), mn/mx);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
R.Destroy();
E.Destroy();
N.Destroy();
ATL.Destroy();
invN.Destroy();
eigenVals.Destroy();
eigenVecs.Destroy();
est_param_incs.Destroy();
} // end of iterations
msg = "********* Final Estimated Parameters *********";
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Rotation Angles:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Omega:\t") + SG_Get_String(rotns[0],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Kappa:\t") + SG_Get_String(rotns[1],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Alpha:\t") + SG_Get_String(rotns[2],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Projection Center:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Xc:\t") + SG_Get_String(center[0],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Yc:\t") + SG_Get_String(center[1],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Zc:\t") + SG_Get_String(center[2],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
if (estPPOffsets) {
msg = SG_T("Principal Point Offsets:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppX:\t") + SG_Get_String(ppOffsetX,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppY:\t") + SG_Get_String(ppOffsetY,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
}
K.Destroy();
rotns.Destroy();
center.Destroy();
target.Destroy();
pTabStream->Close();
return true;
}
CSG_MetaData * CSG_MetaData::Add_Child(const CSG_String &Name, double Content)
{
return( Ins_Child(Name, SG_Get_String(Content, -16), -1) );
}
bool CAHP::On_Execute(void){
int i,j;
int x,y;
float *pCoefs;
float fValue;
float **pMatrix;
float fSum;
CSG_Grid *pOutputGrid;
CSG_Grid **pGrids;
CSG_Table_Record *pRecord;
CSG_Table *pTable;
CSG_Parameter_Grid_List* pGridsList;
CSG_String sMessage;
pTable = Parameters("TABLE")->asTable();
pOutputGrid = Parameters("OUTPUT")->asGrid();
if( (pGridsList = (CSG_Parameter_Grid_List *)Parameters("GRIDS")->Get_Data()) !=
NULL && pGridsList->Get_Count() > 0 ){
if (pTable->Get_Field_Count() != pGridsList->Get_Count() ||
pTable->Get_Record_Count() < pGridsList->Get_Count()){
Message_Add(_TL("Error : Wrong table. Check table dimensions"));
return false;
}//if
pMatrix = new float*[pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
pMatrix[i] = new float[pGridsList->Get_Count()];
pRecord = pTable->Get_Record(i);
for (j = 0; j<pGridsList->Get_Count(); j++){
pMatrix[i][j] = pRecord->asFloat(j);
}//for
}//for
for (i = 0; i<pGridsList->Get_Count(); i++){
fSum = 0;
for (j = 0; j<pGridsList->Get_Count(); j++){
fSum += pMatrix[j][i];
}//for
for (j = 0; j<pGridsList->Get_Count(); j++){
pMatrix[j][i] /= fSum;
}//for
}//for
pCoefs = new float[pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
fSum = 0;
for (j = 0; j<pGridsList->Get_Count(); j++){
fSum += pMatrix[i][j];
}//for
pCoefs[i] = fSum / (float) pGridsList->Get_Count();
sMessage = _TL("Weight for grid ") + SG_Get_String(i,0) + " = " + SG_Get_String(pCoefs[i]);
Message_Add(sMessage.c_str());
}//for
pGrids = new CSG_Grid* [pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
pGrids[i] = pGridsList->asGrid(i);
}//for
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
fValue = 0;
for (i = 0; i<pGridsList->Get_Count(); i++){
fValue = pCoefs[i] * pGrids[i]->asFloat(x,y);
}//for
pOutputGrid->Set_Value(x,y,fValue);
}//for
}//for
}//if
for (i = 0; i<pGridsList->Get_Count(); i++){
delete [] pMatrix[i];
}//for
delete []pMatrix;
delete[] pCoefs;
return true;
}//method
void CSimulateVariableWind::CreateReport(){
CSG_String sReportFile, sFile;
int i;
if (Parameters("REPORTFILE")->asString() != NULL){
sReportFile = Parameters("REPORTFILE")->asString();
CalculateReportParameters();
char cDate[81];
time_t curTime;
tm * timeinfo;
time(&curTime);
timeinfo = gmtime(&curTime);
// std::locale spanish("esp");
// std::locale::global(spanish);
strftime(cDate, 80, "%#x", timeinfo);
sFile += "\t\t\t SIMULACIÓN realizada el ";
sFile += cDate;
sFile += "\n\t\t ==============================================================================";
sFile += "\n\n\t Parámetros de entrada\n";
sFile += "\t --------------------------------\n\n";
sFile += "\t\t Modelos de combustible (por area) \n: ";
for (i = 0; i < 12; i++){
if (m_pAreaByFuelModel[i]){
sFile += "\t\t\t * ";
sFile += SG_Get_String(i + 1, 0) + " : " + SG_Get_String(m_pAreaByFuelModel[i]) + " ha\n";
}//if
}//for
sFile += "\t\t Humedad de los combustibles muertos (1 h): ";
sFile += SG_Get_String(m_fDeadFuelMoisture) + " %\n";
sFile += "\t\t Velocidad del viento a media llama: \n" ;
for(i = 0; i < m_iWindSpdGrids; i++){
sFile += "\t\t\t * ";
sFile += SG_Get_String(i * m_fInterval, 0) + " min: "
+ SG_Get_String(m_pMeanWindSpd[i]) + "Km/h\n";
}//for
sFile += "\t\t Dirección del vector viento, desde el norte geográfico: \n";
for(i = 0; i < m_iWindDirGrids; i++){
sFile += "\t\t\t * ";
sFile += SG_Get_String(i * m_fInterval, 0) + " min: "
+ SG_Get_String(m_pMeanWindDir[i]) + "º\n";
}//for
sFile += "\t\t Pendiente del terreno media: "; sFile += SG_Get_String(m_fSlope) + " %\n";
sFile += "\t\t Orientación del terreno: "; sFile += SG_Get_String(m_fAspect) + "º\n";
sFile += "\t\t Foco de partida: X = "; sFile += SG_Get_String(Parameters("COORDX")->asDouble(), 0) + " / Y = "
+ SG_Get_String(Parameters("COORDY")->asDouble(), 0) + "\n";
sFile += "\t\t Tiempo de simulación: 3.0 h";
sFile += "\n\n\t Resultado de la simulación\n";
sFile += "\t --------------------------------\n\n";
sFile += "\t\t Velocidad de propagación: "; sFile += SG_Get_String(m_fMeanSpeed) + " m/min\n";
sFile += "\t\t Calor por unidad de area: "; sFile += SG_Get_String(m_fHeatPerUnitArea) + " kJ/m^2\n"; //revisar unidades!!
sFile += "\t\t Intensidad de la línea de fuego: "; sFile += SG_Get_String(m_fIntensity) + " kCal/m\n";
sFile += "\t\t Longitud de la llama: "; sFile += SG_Get_String(m_fFlameHeight) + " m\n";
sFile += "\t\t Intensidad de reacción: "; sFile += SG_Get_String(m_fReactionIntensity) + " kCal/m2\n";
sFile += "\t\t Velocidad efectiva del viento: "; sFile += SG_Get_String(m_fEffectiveWind / KMH2FTMIN) + " Km/h\n";
sFile += "\t\t Dirección de máxima propagación, desde el norte geográfico: "; sFile += SG_Get_String(m_fMaxSpreadDir) + "º\n";
sFile += "\t\t Area: "; sFile += SG_Get_String(m_fArea / 10000) + " ha\n";
sFile += "\t\t Perímetro: "; sFile += SG_Get_String(m_fPerimeter) + "m\n";
//Razón Longitud/Ancho: 1.9
sFile += "\t\t Distancia de propagación hacia delante: "; sFile += SG_Get_String(m_fFrontDistance) + " m\n";
sFile += "\t\t Distancia de propagación hacia atrás: "; sFile += SG_Get_String(m_fRearDistance) + " m\n";
CSG_File file;
if( file.Open(sReportFile, SG_FILE_W, false) )
{
file.Write(sFile);
}
}//if
}//method
