//---------------------------------------------------------
void CSG_MetaData::_Save(wxXmlNode *pNode) const
{
int i;
pNode->SetName (Get_Name().Length() ? SG_String_To_UTF8(Get_Name()).c_str() : SG_T("NODE"));
pNode->SetContent(SG_String_To_UTF8(Get_Content()).c_str());
if( Get_Content().Length() > 0 )
{
wxXmlNode *pChild = new wxXmlNode(pNode, wxXML_TEXT_NODE, SG_T("TEXT"));// SG_String_To_UTF8(Get_Name()).c_str());
pChild->SetContent(SG_String_To_UTF8(Get_Content()).c_str());
}
//-----------------------------------------------------
for(i=0; i<Get_Property_Count(); i++)
{
pNode->AddProperty(SG_String_To_UTF8(Get_Property_Name(i)).c_str(), SG_String_To_UTF8(Get_Property(i)).c_str());
}
//-----------------------------------------------------
for(i=Get_Children_Count()-1; i>=0; i--)
{
if( Get_Child(i)->Get_Content().Length() > 0 || Get_Child(i)->Get_Children_Count() > 0 )
{
wxXmlNode *pChild = new wxXmlNode(pNode, wxXML_ELEMENT_NODE, SG_String_To_UTF8(Get_Child(i)->Get_Name()).c_str());
Get_Child(i)->_Save(pChild);
}
}
}
//---------------------------------------------------------
void CSG_MetaData::_Save(wxXmlNode *pNode) const
{
int i;
//-----------------------------------------------------
pNode->SetName (CSG_String(Get_Name().Length() ? Get_Name() : CSG_String("NODE")).c_str());
pNode->SetContent(Get_Content().c_str());
if( Get_Content().Length() > 0 || (Get_Property_Count() == 0 && Get_Children_Count() == 0) )
{
wxXmlNode *pChild = new wxXmlNode(pNode, wxXML_TEXT_NODE, SG_T("TEXT"));
pChild->SetContent(Get_Content().c_str());
}
//-----------------------------------------------------
for(i=0; i<Get_Property_Count(); i++)
{
pNode->AddAttribute(Get_Property_Name(i).c_str(), Get_Property(i));
}
//-----------------------------------------------------
for(i=Get_Children_Count()-1; i>=0; i--)
{
Get_Child(i)->_Save(new wxXmlNode(pNode, wxXML_ELEMENT_NODE, Get_Child(i)->Get_Name().c_str()));
}
}
bool NetGuard_User_State_Check_Maconoff_Enable::checkstate(NetGuard_User_State* state_data)
{
if (state_data->Getuser().vlan_id != my_instance->mof_vlan_id) //if it is not our vlan -> return false which results in use of another handler
return true;
ng_slogdebug_spam(Get_Name().c_str(),"check state change for user (user: %s vlan: %d)",inet_ntoa(*(struct in_addr *)&state_data->Getuser().saddr),state_data->Getuser().vlan_id);
mac_addr n_hw_addr = {0,0,0,0,0,0};
if (compare_mac(state_data->params()->GetMac("mac"),&n_hw_addr))
{
ng_slogerror(Get_Name().c_str(),"invalid enabled state - no mac in params (user: %s vlan: %d)",inet_ntoa(*(struct in_addr *)&state_data->Getuser().saddr),state_data->Getuser().vlan_id);
return false;
}
return true;
}
//---------------------------------------------------------
CSG_String CSG_MetaData::asText(int Flags) const
{
CSG_String s;
if( Flags == 0 )
{
for(int i=0; i<Get_Children_Count(); i++)
{
s += Get_Child(i)->Get_Name() + ":\t" + Get_Child(i)->Get_Content() + "\n";
}
}
else
{
wxXmlDocument XML;
wxXmlNode *pRoot = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, Get_Name().c_str());
XML.SetRoot(pRoot);
_Save(pRoot);
wxStringOutputStream Stream;
XML.Save(Stream);
s = &Stream.GetString();
if( Flags == 2 ) // remove <xml>
{
s = s.AfterFirst('\n');
}
}
return( s );
}
//---------------------------------------------------------
wxString CWKSP_Module_Group::Get_Description(void)
{
wxString s;
s += wxString::Format("<h4>%s</h4>", _TL("Tool Libraries"));
s += "<table border=\"0\">";
s += SUMMARY_ADD_STR(_TL("Category" ), Get_Name().c_str());
s += SUMMARY_ADD_INT(_TL("Libraries"), Get_Count());
s += "</table>";
//-----------------------------------------------------
s += wxString::Format("<hr><h4>%s</h4><table border=\"0\">", _TL("Tool Libraries"));
s += wxString::Format("<tr align=\"left\"><th>%s</th><th>%s</th><th>%s</th></tr>",
_TL("Library"),
_TL("Name" ),
_TL("Tools" )
);
for(int i=0; i<Get_Count(); i++)
{
s += wxString::Format("<tr><td valign=\"top\"><i>%s</i></td><td valign=\"top\">%s</td><td valign=\"top\" align=\"right\">%d</td></tr>",
Get_Library(i)->Get_Library()->Get_Library_Name().c_str(),
Get_Library(i)->Get_Name().c_str(),
Get_Library(i)->Get_Count()
);
}
s += "</table>";
return( s );
}
//---------------------------------------------------------
bool CViGrA_Watershed::On_Execute(void)
{
CSG_Grid *pInput = Parameters("INPUT" )->asGrid();
CSG_Grid *pOutput = Parameters("OUTPUT")->asGrid();
//-----------------------------------------------------
if( !Parameters("RGB")->asBool() )
{
vigra::FImage Input, Output(Get_NX(), Get_NY());
Copy_Grid_SAGA_to_VIGRA(*pInput, Input, true);
Segmentation(Input, Output, Parameters("SCALE")->asDouble(), Parameters("EDGES")->asBool());
Copy_Grid_VIGRA_to_SAGA(*pOutput, Output, false);
}
//-----------------------------------------------------
else // perform watershed segmentation on color image
{
vigra::BRGBImage Input, Output(Get_NX(), Get_NY());
Copy_RGBGrid_SAGA_to_VIGRA(*pInput, Input, true);
Segmentation(Input, Output, Parameters("SCALE")->asDouble(), Parameters("EDGES")->asBool());
Copy_RGBGrid_VIGRA_to_SAGA(*pOutput, Output, false);
}
//-----------------------------------------------------
pOutput->Fmt_Name("%s [%s]", pInput->Get_Name(), Get_Name().c_str());
return( true );
}
//---------------------------------------------------------
bool CSG_MetaData::to_XML(CSG_String &_XML) const
{
wxXmlDocument XML;
wxXmlNode *pRoot = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, Get_Name().c_str());
XML.SetRoot(pRoot);
_Save(pRoot);
wxMemoryOutputStream Stream;
if( XML.Save(Stream) )
{
CSG_Array s(sizeof(char), Stream.GetSize());
Stream.CopyTo(s.Get_Array(), s.Get_Size());
_XML = (const char *)s.Get_Array();
return( true );
}
return( false );
}
//---------------------------------------------------------
wxString CWKSP_Grid_System::Get_Description(void)
{
wxString s;
s.Printf(wxT("<b>%s</b><table border=\"0\">"), LNG("[CAP] Grid System"));
s.Append(wxString::Format(wxT("<tr><td>%s</td><td>%s</td></tr>"),
LNG("[CAP] Name") , Get_Name().c_str()
));
s.Append(wxString::Format(wxT("<tr><td>%s</td><td>%d</td></tr>"),
LNG("[CAP] Number Of Grids") , Get_Count()
));
s.Append(wxString::Format(wxT("<tr><td>%s</td><td>%d (x) * %d (y) = %ld</td></tr>"),
LNG("[CAP] Number Of Cells") , m_System.Get_NX(), m_System.Get_NY(), m_System.Get_NCells()
));
s.Append(wxString::Format(wxT("<tr><td>%s</td><td>%f</td></tr>"),
LNG("[CAP] Cell Size") , m_System.Get_Cellsize()
));
s.Append(wxString::Format(wxT("<tr><td>%s</td><td>[%f] - [%f] = [%f]</td></tr>"),
LNG("[CAP] West-East") , m_System.Get_XMin(), m_System.Get_XMax(), m_System.Get_XRange()
));
s.Append(wxString::Format(wxT("<tr><td>%s</td><td>[%f] - [%f] = [%f]</td></tr>"),
LNG("[CAP] South-North") , m_System.Get_YMin(), m_System.Get_YMax(), m_System.Get_YRange()
));
s.Append(wxT("</table>"));
//-----------------------------------------------------
return( s );
}
//---------------------------------------------------------
bool C_Kriging_Base::_Get_Grid(void)
{
CSG_Shapes *pShapes = Parameters("SHAPES")->asShapes();
m_pGrid = NULL;
m_pVariance = NULL;
//-------------------------------------------------
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( Dlg_Parameters("USER") )
{
m_pGrid = _Get_Grid(pShapes->Get_Extent());
}
break;
case 1: // grid system...
if( Dlg_Parameters("SYSTEM") )
{
m_pGrid = SG_Create_Grid(*Get_Parameters("SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), SG_DATATYPE_Float);
}
break;
case 2: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = Get_Parameters("GRID")->Get_Parameter("GRID") ->asGrid();
m_pVariance = Get_Parameters("GRID")->Get_Parameter("VARIANCE") ->asGrid();
}
break;
}
//-------------------------------------------------
if( m_pGrid )
{
if( !m_pVariance && Parameters("BVARIANCE")->asBool() )
{
m_pVariance = SG_Create_Grid(m_pGrid, SG_DATATYPE_Float);
}
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s (%s)"), pShapes->Get_Name(), Get_Name()));
Parameters("GRID")->Set_Value(m_pGrid);
if( m_pVariance )
{
m_pVariance->Set_Name(CSG_String::Format(SG_T("%s (%s - %s)"), pShapes->Get_Name(), Get_Name(), _TL("Variance")));
Parameters("VARIANCE")->Set_Value(m_pVariance);
}
if( Parameters("TARGET")->asInt() == 2 )
{
Get_Parameters("GRID")->Get_Parameter("VARIANCE")->Set_Value(m_pVariance);
}
}
//-----------------------------------------------------
return( m_pGrid != NULL );
}
//---------------------------------------------------------
bool CViGrA_Morphology::On_Execute(void)
{
bool bRescale;
int Type, Radius;
double Rank;
CSG_Grid *pInput, *pOutput, Rescaled;
pInput = Parameters("INPUT") ->asGrid();
pOutput = Parameters("OUTPUT") ->asGrid();
Type = Parameters("TYPE") ->asInt();
Radius = Parameters("RADIUS") ->asInt();
Rank = Parameters("RANK") ->asDouble();
bRescale = Parameters("RESCALE") ->asBool();
//-----------------------------------------------------
if( bRescale )
{
Rescaled.Create(*Get_System(), SG_DATATYPE_Byte);
for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++)
{
Rescaled.Set_Value(i, 0.5 + (pInput->asDouble(i) - pInput->Get_ZMin()) * 255.0 / pInput->Get_ZRange());
}
pInput = &Rescaled;
}
//-----------------------------------------------------
vigra::BImage Input, Output(Get_NX(), Get_NY());
Copy_Grid_SAGA_to_VIGRA(*pInput, Input, true);
switch( Type )
{
case 0: // Dilation
discDilation (srcImageRange(Input), destImage(Output), Radius);
break;
case 1: // Erosion
discErosion (srcImageRange(Input), destImage(Output), Radius);
break;
case 2: // Median
discMedian (srcImageRange(Input), destImage(Output), Radius);
break;
case 3: // User defined rank
discRankOrderFilter (srcImageRange(Input), destImage(Output), Radius, Rank);
break;
}
//-----------------------------------------------------
Copy_Grid_VIGRA_to_SAGA(*pOutput, Output, false);
pOutput->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pInput->Get_Name(), Get_Name().c_str()));
return( true );
}
bool NetGuard_User_SCE_Maconoff::set_failure_state(NetGuard_User_State *user, std::string error)
{
NetGuard_State *my_state_f = NetGuard_State_Handler::get_state(GlobalCFG::GetStr("mof.failure_state","failure"));
if (!my_state_f) {
ng_slogerror(Get_Name().c_str(),"%s state %s unkown",__FUNCTION__,GlobalCFG::GetStr("mof.failure_state","failure").c_str());
return false;
}
return user->set(my_state_f,error);
}
//---------------------------------------------------------
wxMenu * CWKSP_Grid_System::Get_Menu(void)
{
wxMenu *pMenu;
pMenu = new wxMenu(Get_Name());
CMD_Menu_Add_Item(pMenu, false, ID_CMD_WKSP_ITEM_CLOSE);
return( pMenu );
}
//---------------------------------------------------------
wxMenu * CWKSP_Tool_Library::Get_Menu(void)
{
wxMenu *pMenu;
pMenu = new wxMenu(Get_Name());
CMD_Menu_Add_Item(pMenu, false, ID_CMD_WKSP_ITEM_CLOSE);
return( pMenu );
}
//---------------------------------------------------------
bool CWKSP_Map_Layer::On_Command(int Cmd_ID)
{
switch( Cmd_ID )
{
default:
return( CWKSP_Base_Item::On_Command(Cmd_ID) );
case ID_CMD_SHAPES_EDIT_SHAPE:
case ID_CMD_SHAPES_EDIT_ADD_SHAPE:
case ID_CMD_SHAPES_EDIT_DEL_SHAPE:
case ID_CMD_SHAPES_EDIT_ADD_PART:
case ID_CMD_SHAPES_EDIT_DEL_PART:
case ID_CMD_SHAPES_EDIT_DEL_POINT:
case ID_CMD_SHAPES_EDIT_SEL_CLEAR:
case ID_CMD_SHAPES_EDIT_SEL_INVERT:
return( m_pLayer->On_Command(Cmd_ID) );
case ID_CMD_WKSP_ITEM_RETURN:
case ID_CMD_MAPS_LAYER_SHOW:
m_bShow = !m_bShow;
((wxTreeCtrl *)Get_Control())->SetItemText(GetId(), Get_Name());
((CWKSP_Map *)Get_Manager())->View_Refresh(true);
break;
case ID_CMD_MAPS_MOVE_TOP:
if( Get_Manager()->Move_Top(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_MOVE_BOTTOM:
if( Get_Manager()->Move_Bottom(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_MOVE_UP:
if( Get_Manager()->Move_Up(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_MOVE_DOWN:
if( Get_Manager()->Move_Down(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_GRID_FITCOLORS:
if( m_pLayer->Get_Type() == WKSP_ITEM_Grid )
((CWKSP_Grid *)m_pLayer)->Fit_Color_Range(((CWKSP_Map *)Get_Manager())->Get_Extent());
break;
}
return( true );
}
//---------------------------------------------------------
void CWKSP_Base_Item::Parameters_Changed(void)
{
if( Get_Control() && GetId().IsOk() )
{
Get_Control()->SetItemText(GetId(), Get_Name());
}
if( g_pACTIVE )
{
g_pACTIVE->Update_Description();
g_pACTIVE->Update(this, false);
}
}
//---------------------------------------------------------
bool CSG_MetaData::Save(const CSG_String &File, const SG_Char *Extension) const
{
wxXmlDocument XML;
wxXmlNode *pRoot = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, Get_Name().c_str());
XML.SetRoot(pRoot);
_Save(pRoot);
if( XML.Save(SG_File_Make_Path(NULL, File, Extension).c_str()) )
{
return( true );
}
return( false );
}
int
p_get_env(value v0, type t0,
value v1, type t1)
{
extern char *getenv();
char *name;
value v;
Get_Name(v0,t0,name)
name = getenv(name);
if(name == (char *) 0)
{
Fail;
}
Cstring_To_Prolog(name, v);
Return_Unify_String(v1, t1, v.ptr)
}
//---------------------------------------------------------
bool CSG_MetaData::Save(CSG_File &File) const
{
wxXmlDocument XML;
wxXmlNode *pRoot = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, Get_Name().c_str());
XML.SetRoot(pRoot);
_Save(pRoot);
if( File.is_Writing() && XML.Save(*((wxOutputStream *)File.Get_Stream())) )
{
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CSG_MetaData::Save(CSG_File &File) const
{
wxXmlDocument XML;
wxXmlNode *pRoot = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, Get_Name().c_str());
XML.SetRoot(pRoot);
_Save(pRoot);
wxFFileOutputStream Stream(File.Get_Stream());
if( Stream.IsOk() && XML.Save(Stream) )
{
return( true );
}
return( false );
}
bool cJoystick :: Stick_Open( unsigned int index )
{
// if a joystick is already opened close it first
if( m_joystick_open )
{
Stick_Close();
}
m_joystick = SDL_JoystickOpen( index );
if( !m_joystick )
{
printf( "Couldn't open joystick %d\n", index );
m_joystick_open = 0;
return 0;
}
m_current_joystick = index;
m_num_buttons = SDL_JoystickNumButtons( m_joystick );
m_num_axes = SDL_JoystickNumAxes( m_joystick );
m_num_balls = SDL_JoystickNumBalls( m_joystick );
// setup available buttons
m_buttons.assign( m_num_buttons, 0 );
if( m_debug )
{
printf( "Opened Joystick %d\n", m_current_joystick );
printf( "Name: %s\n", Get_Name().c_str() );
printf( "Number of Buttons: %d\n", m_num_buttons );
printf( "Number of Axes: %d\n", m_num_axes );
printf( "Number of Balls: %d\n\n", m_num_balls );
}
m_joystick_open = 1;
return 1;
}
//---------------------------------------------------------
bool CWKSP_Map_Graticule::On_Command(int Cmd_ID)
{
switch( Cmd_ID )
{
default:
return( CWKSP_Base_Item::On_Command(Cmd_ID) );
case ID_CMD_WKSP_ITEM_RETURN:
case ID_CMD_MAPS_LAYER_SHOW:
m_bShow = !m_bShow;
((wxTreeCtrl *)Get_Control())->SetItemText(GetId(), Get_Name());
((CWKSP_Map *)Get_Manager())->View_Refresh(true);
break;
case ID_CMD_MAPS_MOVE_TOP:
if( Get_Manager()->Move_Top(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_MOVE_BOTTOM:
if( Get_Manager()->Move_Bottom(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_MOVE_UP:
if( Get_Manager()->Move_Up(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
case ID_CMD_MAPS_MOVE_DOWN:
if( Get_Manager()->Move_Down(this) )
((CWKSP_Map *)Get_Manager())->View_Refresh(false);
break;
}
return( true );
}
//---------------------------------------------------------
bool COpenCV_Morphology::On_Execute(void)
{
int Type, Shape, Radius, Iterations;
CSG_Grid *pInput, *pOutput;
pInput = Parameters("INPUT") ->asGrid();
pOutput = Parameters("OUTPUT") ->asGrid();
Type = Parameters("TYPE") ->asInt();
Shape = Parameters("SHAPE") ->asInt();
Radius = Parameters("RADIUS") ->asInt();
Iterations = Parameters("ITERATIONS") ->asInt();
//-----------------------------------------------------
switch( Shape )
{
default:
case 0: Shape = CV_SHAPE_ELLIPSE; break;
case 1: Shape = CV_SHAPE_RECT; break;
case 2: Shape = CV_SHAPE_CROSS; break;
}
//-----------------------------------------------------
IplImage *cv_pInput = Get_CVImage(pInput);
IplImage *cv_pOutput = Get_CVImage(Get_NX(), Get_NY(), pInput->Get_Type());
IplImage *cv_pTmp = NULL;
//-----------------------------------------------------
IplConvKernel *cv_pElement = cvCreateStructuringElementEx(Radius * 2 + 1, Radius * 2 + 1, Radius, Radius, Shape, 0);
switch( Type )
{
case 0: // dilation
cvDilate (cv_pInput, cv_pOutput, cv_pElement, Iterations);
break;
case 1: // erosion
cvErode (cv_pInput, cv_pOutput, cv_pElement, Iterations);
break;
case 2: // opening
cvMorphologyEx (cv_pInput, cv_pOutput, cv_pTmp,
cv_pElement, CV_MOP_OPEN , Iterations
);
break;
case 3: // closing
cvMorphologyEx (cv_pInput, cv_pOutput, cv_pTmp,
cv_pElement, CV_MOP_CLOSE , Iterations
);
break;
case 4: // morpological gradient
cvMorphologyEx (cv_pInput, cv_pOutput, cv_pTmp = Get_CVImage(Get_NX(), Get_NY(), pInput->Get_Type()),
cv_pElement, CV_MOP_GRADIENT, Iterations
);
break;
case 5: // top hat
cvMorphologyEx (cv_pInput, cv_pOutput, cv_pTmp = Get_CVImage(Get_NX(), Get_NY(), pInput->Get_Type()),
cv_pElement, CV_MOP_TOPHAT , Iterations
);
break;
case 6: // black hat
cvMorphologyEx (cv_pInput, cv_pOutput, cv_pTmp = Get_CVImage(Get_NX(), Get_NY(), pInput->Get_Type()),
cv_pElement, CV_MOP_BLACKHAT, Iterations
);
break;
}
cvReleaseStructuringElement(&cv_pElement);
//-----------------------------------------------------
Copy_CVImage_To_Grid(pOutput, cv_pOutput);
cvReleaseImage(&cv_pInput);
cvReleaseImage(&cv_pOutput);
if( cv_pTmp )
{
cvReleaseImage(&cv_pTmp);
}
pOutput->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pInput->Get_Name(), Get_Name().c_str()));
return( true );
}
//---------------------------------------------------------
bool CKriging_Base::_Initialise_Grids(void)
{
m_pGrid = NULL;
m_pVariance = NULL;
//-----------------------------------------------------
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
if( Get_Parameters("USER")->Get_Parameter("BVARIANCE")->asBool() )
{
m_pVariance = m_Grid_Target.Get_User(SG_T("VARIANCE"));
}
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
m_pVariance = m_Grid_Target.Get_Grid(SG_T("VARIANCE"));
}
break;
}
if( !m_pGrid )
{
return( false );
}
//-----------------------------------------------------
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("ZFIELD")->asString(), Get_Name().c_str()));
if( m_pVariance )
{
m_pVariance->Set_Name(CSG_String::Format(SG_T("%s [%s %s]"), Parameters("ZFIELD")->asString(), Get_Name().c_str(), m_bStdDev ? _TL("Standard Deviation") : _TL("Variance")));
}
return( true );
}
//---------------------------------------------------------------
bool FileHandler_C::Exists() {
ifstream f( Get_Name() );
return f.good() ;
};
//---------------------------------------------------------
bool CInterpolation::On_Execute(void)
{
bool bResult = false;
//-----------------------------------------------------
m_pShapes = Parameters("SHAPES") ->asShapes();
m_zField = Parameters("FIELD") ->asInt();
//-----------------------------------------------------
m_pGrid = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pShapes->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
}
break;
}
//-----------------------------------------------------
if( m_pGrid )
{
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("FIELD")->asString(), Get_Name().c_str()));
bResult = Interpolate();
}
//-----------------------------------------------------
m_Search.Destroy();
if( m_pShapes != Parameters("SHAPES")->asShapes() )
{
delete(m_pShapes);
}
return( bResult );
}
//---------------------------------------------------------
bool CSG_Grid::_Save_Native(const CSG_String &File_Name, int xA, int yA, int xN, int yN, bool bBinary)
{
bool bResult = false;
CSG_File Stream;
if( Stream.Open(File_Name, SG_FILE_W, false) )
{
//-------------------------------------------------
// Header...
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_NAME ], Get_Name() );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_DESCRIPTION ], Get_Description() );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_UNITNAME ], Get_Unit() );
Stream.Printf(SG_T("%s\t= %d\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_DATAFILE_OFFSET], 0 );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_DATAFORMAT ], bBinary ? gSG_Data_Type_Identifier[Get_Type()] : SG_T("ASCII") );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_BYTEORDER_BIG ], GRID_FILE_KEY_FALSE );
Stream.Printf(SG_T("%s\t= %.10f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_POSITION_XMIN ], Get_XMin() + Get_Cellsize() * xA );
Stream.Printf(SG_T("%s\t= %.10f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_POSITION_YMIN ], Get_YMin() + Get_Cellsize() * yA );
Stream.Printf(SG_T("%s\t= %d\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_CELLCOUNT_X ], xN );
Stream.Printf(SG_T("%s\t= %d\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_CELLCOUNT_Y ], yN );
Stream.Printf(SG_T("%s\t= %.10f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_CELLSIZE ], Get_Cellsize() );
Stream.Printf(SG_T("%s\t= %f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_Z_FACTOR ], m_zFactor );
Stream.Printf(SG_T("%s\t= %f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_NODATA_VALUE ], Get_NoData_Value() );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_TOPTOBOTTOM ], GRID_FILE_KEY_FALSE );
//-------------------------------------------------
// Data...
if( Stream.Open(SG_File_Make_Path(NULL, File_Name, SG_T("sdat")), SG_FILE_W, true) )
{
if( bBinary )
{
bResult = _Save_Binary (Stream, xA, yA, xN, yN, Get_Type(), false, false);
}
else
{
bResult = _Save_ASCII (Stream, xA, yA, xN, yN);
}
}
}
return( bResult );
}
//---------------------------------------------------------
bool CSADO_SolarRadiation::On_Execute(void)
{
//-----------------------------------------------------
m_pDEM = Parameters("GRD_DEM") ->asGrid();
m_pVP = Parameters("GRD_VAPOUR") ->asGrid();
m_pSumDirect = Parameters("GRD_DIRECT") ->asGrid();
m_bUpdateDirect = Parameters("UPD_DIRECT") ->asBool() && m_pSumDirect;
m_pSumDiffus = Parameters("GRD_DIFFUS") ->asGrid();
m_bUpdateDiffus = Parameters("UPD_DIFFUS") ->asBool() && m_pSumDiffus;
m_pSumTotal = Parameters("GRD_TOTAL") ->asGrid();
m_bUpdateTotal = Parameters("UPD_TOTAL") ->asBool() && m_pSumTotal;
m_Solar_Const = Parameters("SOLARCONST") ->asDouble();
m_Atmosphere = Parameters("ATMOSPHERE") ->asDouble();
m_VP = Parameters("VAPOUR") ->asDouble();
m_bHorizon = Parameters("BHORIZON") ->asBool();
m_Latitude = Parameters("LATITUDE") ->asDouble() * M_DEG_TO_RAD;
m_bBending = Parameters("BENDING") ->asBool();
m_Hour = Parameters("MOMENT") ->asDouble();
m_dHour = Parameters("DHOUR") ->asDouble();
m_dDays = Parameters("DDAYS") ->asInt();
m_Day_A = Parameters("DAY_A") ->asInt();
m_Day_B = Parameters("DAY_B") ->asInt();
switch( Parameters("PERIOD")->asInt() )
{
case 0: // moment
m_bMoment = true;
m_bUpdateDirect = m_bUpdateDiffus = m_bUpdateTotal = false;
break;
case 1: // day
m_bMoment = false;
m_Day_B = m_Day_A;
m_Hour = 0.0;
break;
case 2: // range of days
m_bMoment = false;
m_Hour = 0.0;
break;
case 3: // same moment for a range of days
m_bMoment = false;
m_dHour = 24.0;
break;
}
//-----------------------------------------------------
if( !m_pSumDirect && !m_pSumDiffus && !m_pSumTotal )
{
Message_Dlg(_TL("No output grid has been choosen."), Get_Name());
}
else if( m_pSumDirect == m_pDEM || m_pSumDiffus == m_pDEM || m_pSumTotal == m_pDEM )
{
Message_Dlg(_TL("Output must not overwrite elevation grid."), Get_Name());
}
else
{
return( Get_Insolation() );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CGridding_Spline_Base::_Get_Grid(void)
{
CSG_Grid *pGrid = m_bGridPoints ? Parameters("GRIDPOINTS")->asGrid () : NULL;
CSG_Shapes *pShapes = !m_bGridPoints ? Parameters("SHAPES") ->asShapes() : NULL;
//-----------------------------------------------------
m_pGrid = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_bGridPoints ? pGrid->Get_Extent() : pShapes->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
}
break;
}
//-------------------------------------------------
if( m_pGrid )
{
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_bGridPoints ? pGrid->Get_Name() : pShapes->Get_Name(), Get_Name()));
m_pGrid->Assign_NoData();
}
//-----------------------------------------------------
return( m_pGrid != NULL );
}
LOCAL_FUNC
FT_Error SFNT_Load_Face(FT_Stream stream,
TT_Face face,
FT_Int face_index,
FT_Int num_params,
FT_Parameter *params)
{
FT_Error error;
SFNT_Interface *sfnt = (SFNT_Interface *)face->sfnt;
FT_UNUSED(face_index);
FT_UNUSED(num_params);
FT_UNUSED(params);
/* Load tables */
if(LOAD_(header) ||
LOAD_(max_profile) ||
/* load the `hhea' & `hmtx' tables at once */
(error = sfnt->load_metrics(face, stream, 0)) != TT_Err_Ok ||
/* try to load the `vhea' & `vmtx' at once if present */
(error = sfnt->load_metrics(face, stream, 1)) != TT_Err_Ok ||
LOAD_(charmaps) ||
LOAD_(names) ||
LOAD_(os2) ||
LOAD_(psnames))
{
goto Exit;
}
/* the optional tables */
#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
/* embedded bitmap support. */
if(sfnt->load_sbits && LOAD_(sbits))
{
goto Exit;
}
#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
if(LOAD_(hdmx) ||
LOAD_(gasp) ||
LOAD_(kerning) ||
LOAD_(pclt))
{
goto Exit;
}
#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
if((error = TT_Extension_Create(face)) != TT_Err_Ok)
{
goto Exit;
}
#endif
face->root.family_name = Get_Name(face, TT_NAME_ID_FONT_FAMILY);
face->root.style_name = Get_Name(face, TT_NAME_ID_FONT_SUBFAMILY);
/* now set up root fields */
{
FT_Face root = &face->root;
FT_Int flags;
TT_CharMap charmap;
FT_Int n;
FT_Memory memory;
memory = root->memory;
/*********************************************************************/
/* */
/* Compute face flags. */
/* */
flags = FT_FACE_FLAG_SCALABLE | /* scalable outlines */
FT_FACE_FLAG_SFNT | /* SFNT file format */
FT_FACE_FLAG_HORIZONTAL; /* horizontal data */
#ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
/* might need more polish to detect the presence of a Postscript */
/* name table in the font */
flags |= FT_FACE_FLAG_GLYPH_NAMES;
#endif
/* fixed width font? */
if(face->postscript.isFixedPitch)
{
flags |= FT_FACE_FLAG_FIXED_WIDTH;
}
/* vertical information? */
if(face->vertical_info)
{
flags |= FT_FACE_FLAG_VERTICAL;
}
/* kerning available ? */
if(face->kern_pairs)
{
flags |= FT_FACE_FLAG_KERNING;
}
root->face_flags = flags;
/*********************************************************************/
/* */
/* Compute style flags. */
/* */
flags = 0;
if(face->os2.version != 0xFFFF)
{
/* we have an OS/2 table; use the `fsSelection' field */
if(face->os2.fsSelection & 1)
{
flags |= FT_STYLE_FLAG_ITALIC;
}
if(face->os2.fsSelection & 32)
{
flags |= FT_STYLE_FLAG_BOLD;
}
}
else
{
/* this is an old Mac font, use the header field */
if(face->header.Mac_Style & 1)
{
flags |= FT_STYLE_FLAG_BOLD;
}
if(face->header.Mac_Style & 2)
{
flags |= FT_STYLE_FLAG_ITALIC;
}
}
root->style_flags = flags;
/*********************************************************************/
/* */
/* Polish the charmaps. */
/* */
/* Try to set the charmap encoding according to the platform & */
/* encoding ID of each charmap. */
/* */
charmap = face->charmaps;
root->num_charmaps = face->num_charmaps;
/* allocate table of pointers */
if(ALLOC_ARRAY(root->charmaps, root->num_charmaps, FT_CharMap))
{
goto Exit;
}
for(n = 0; n < root->num_charmaps; n++, charmap++)
{
FT_Int platform = charmap->cmap.platformID;
FT_Int encoding = charmap->cmap.platformEncodingID;
charmap->root.face = (FT_Face)face;
charmap->root.platform_id = platform;
charmap->root.encoding_id = encoding;
charmap->root.encoding = find_encoding(platform, encoding);
/* now, set root->charmap with a unicode charmap */
/* wherever available */
if(!root->charmap &&
charmap->root.encoding == ft_encoding_unicode)
{
root->charmap = (FT_CharMap)charmap;
}
root->charmaps[n] = (FT_CharMap)charmap;
}
#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
if(face->num_sbit_strikes)
{
root->num_fixed_sizes = face->num_sbit_strikes;
if(ALLOC_ARRAY(root->available_sizes,
face->num_sbit_strikes,
FT_Bitmap_Size))
{
return error;
}
for(n = 0 ; n < face->num_sbit_strikes ; n++)
{
root->available_sizes[n].width =
face->sbit_strikes[n].x_ppem;
root->available_sizes[n].height =
face->sbit_strikes[n].y_ppem;
}
}
else
{
#else /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
{
root->num_fixed_sizes = 0;
root->available_sizes = 0;
}
#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ {
/*********************************************************************/
/* */
/* Set up metrics. */
/* */
root->bbox.xMin = face->header.xMin;
}
root->bbox.yMin = face->header.yMin;
root->bbox.xMax = face->header.xMax;
root->bbox.yMax = face->header.yMax;
root->units_per_EM = face->header.Units_Per_EM;
/* The ascender/descender/height are computed from the OS/2 table */
/* when found. Otherwise, they're taken from the horizontal header. */
if(face->os2.version != 0xFFFF)
{
root->ascender = face->os2.sTypoAscender;
root->descender = -face->os2.sTypoDescender;
root->height = root->ascender + root->descender +
face->os2.sTypoLineGap;
}
else
{
root->ascender = face->horizontal.Ascender;
root->descender = face->horizontal.Descender;
root->height = root->ascender + root->descender +
face->horizontal.Line_Gap;
}
root->max_advance_width = face->horizontal.advance_Width_Max;
root->max_advance_height = face->vertical_info
? face->vertical.advance_Height_Max
: root->height;
root->underline_position = face->postscript.underlinePosition;
root->underline_thickness = face->postscript.underlineThickness;
/* root->max_points -- already set up */
/* root->max_contours -- already set up */
}
Exit:
return error;
}
