Beispiel #1
0
//---------------------------------------------------------
bool CFilter_LoG::On_Execute(void)
{
	//-----------------------------------------------------
	if( !Initialise() )
	{
		return( false );
	}

	//-----------------------------------------------------
	m_pInput	= Parameters("INPUT")->asGrid();

	CSG_Grid	Result, *pResult	= Parameters("RESULT")->asGrid();

	if( !pResult || pResult == m_pInput )
	{
		pResult	= &Result;
		
		pResult->Create(m_pInput);
	}
	else
	{
		pResult->Set_Name(CSG_String::Format("%s [%s]", m_pInput->Get_Name(), _TL("Laplace Filter")));

		pResult->Set_NoData_Value(m_pInput->Get_NoData_Value());
	}

	//-----------------------------------------------------
	for(int y=0; y<Get_NY() && Set_Progress(y); y++)
	{
		#pragma omp parallel for
		for(int x=0; x<Get_NX(); x++)
		{
			if( m_pInput->is_InGrid(x, y) )
			{
				pResult->Set_Value(x, y, Get_Value(x, y));
			}
			else
			{
				pResult->Set_NoData(x, y);
			}
		}
	}

	//-----------------------------------------------------
	if( pResult == &Result )
	{
		CSG_MetaData	History	= m_pInput->Get_History();

		m_pInput->Assign(pResult);
		m_pInput->Get_History() = History;

		DataObject_Update(m_pInput);

		Parameters("RESULT")->Set_Value(m_pInput);
	}

	DataObject_Set_Colors(pResult, 100, SG_COLORS_BLACK_WHITE);

	m_Kernel.Destroy();

	return( true );
}
Beispiel #2
0
CMOOSDBHTTPServer::CMOOSDBHTTPServer(long lDBPort, long lWebServerPort)
{
    Initialise(lDBPort, lWebServerPort);
}
BoundedArray<T>::BoundedArray(unsigned int _numElements)
{
	Initialise( _numElements );
}
Beispiel #4
0
CSystemTray::CSystemTray()
{
    Initialise();
}
Beispiel #5
0
Point::Point()
{
	Initialise();
}
void MoveHeroTo(int row, int column) // Ћогика движени¤ геро¤
{
	unsigned char destinationCell = levelData[row][column];
	bool canMoveToCell = false; // √ерой не может пройти в ¤чейку


	switch (destinationCell)
	{
		// —вободна¤ ¤чейка
		case ' ':
		{
			canMoveToCell = true; // √ерой может пройти в ¤чейку
			break;
		}

		// ячейка-выход с ключом
		case symbolExitKey:
		{
			if (isKey)
			{
				// ѕереход на следующий уровень
				++level;
				if (level < levelCount)
					Initialise();
				else
					isGameActive = false;
			}

			isKey = false;
			break;
		}
		
		// ячейка-выход с расставленными ¤щиками
		case symbolBoxExit:
        {
			if (filledBoxArea == boxAreaCount)
			    {
                    // ѕереход на следующий уровень
				    ++level;
				    if (level < 15)
					    Initialise();
				    else
					    isGameActive = false; 
                }

            break;    
        }

		// ячейка-выход
		case symbolExit:
		{
			if (collectedCrystals == crystalsCount)
			{
				// ѕереход на следующий уровень
				++level;
				if (level < levelCount)
					Initialise();
				else
					isGameActive = false;
			}

			break;
		}

		// ячейка-мина
		case symbolMine:
		{
			Initialise();
			break;
		}

		// ячейка-кристалл
		case symbolCrystal:
		{
			canMoveToCell = true;
			collectedCrystals++;
			break;
		}

		// ячейка-ключ
		case symbolKey:
		{
			canMoveToCell = true;
			isKey = true;
			break;
		}
		
		 // ячейка места дл¤ ¤щика
		case symbolBoxArea:
		{
			canMoveToCell = true;
		    break;
		}

		// ячейка-¤щик
		case symbolBox:
		{
			// –асчЄт направлени¤ движени¤ геро¤:
			int heroDirectionR = row - heroRow;
			int heroDirectionC = column - heroColumn;

			// ѕроверка на наличие свободной ¤чейки за ¤щиком:
			if (levelData[row + heroDirectionR][column + heroDirectionC] == ' ')
			{
			    canMoveToCell = true;
			    
			    if (levelData0[level][row][column] == 'B')
                    filledBoxArea--;

				// ”даление ¤щика с его нынешней ¤чейки и замена этой ¤чейки на пустую:
				levelData[row][column] = ' ';

				// ѕеремещение ¤щика на новую ¤чейку:
				levelData[row + heroDirectionR][column + heroDirectionC] = symbolBox;
			}
			
			// ѕроверка на наличие свободного места дл¤ ¤щика за ¤щиком:
			if (levelData[row + heroDirectionR][column + heroDirectionC] == symbolBoxArea)
			{
   				canMoveToCell = true;

				// ”даление ¤щика с его нынешней ¤чейки и замена этой ¤чейки на пустую:
				levelData[row][column] = ' ';
                
				// ѕеремещение ¤щика на новую ¤чейку:
				levelData[row + heroDirectionR][column + heroDirectionC] = symbolBox;
				
				filledBoxArea++;
 			}

			break;
		}
	}


	if (canMoveToCell)
	{
        // ”даление геро¤ с его нынешней ¤чейки и замена этой ¤чейки на ¤чейку места дл¤ ¤щика:
        if (levelData0[level][heroRow][heroColumn] == 'B')
        {
            levelData[heroRow][heroColumn] = symbolBoxArea;
            heroRow = row;
            heroColumn = column;
            levelData[heroRow][heroColumn] = symbolHero;
        }
        
		// ”даление геро¤ с его нынешней ¤чейки и замена этой ¤чейки на пустую:
		levelData[heroRow][heroColumn] = ' ';

		// ”становка новой ¤чейки дл¤ геро¤:
		heroRow = row;
		heroColumn = column;

		// ѕеремещение геро¤ на новую ¤чейку:
		levelData[heroRow][heroColumn] = symbolHero;
	}
}
void MathPluginManagement::ProcessSwitchProperties(Telescope* pTelescope, const char *name, ISState *states, char *names[], int n)
{
    DEBUGFDEVICE(pTelescope->getDeviceName(), INDI::Logger::DBG_DEBUG, "ProcessSwitchProperties - name(%s)", name);
    if (strcmp(name, AlignmentSubsystemMathPluginsV.name) == 0)
    {
        int CurrentPlugin = IUFindOnSwitchIndex(&AlignmentSubsystemMathPluginsV);
        IUUpdateSwitch(&AlignmentSubsystemMathPluginsV, states, names, n);
        AlignmentSubsystemMathPluginsV.s = IPS_OK; // Assume OK for the time being
        int NewPlugin  = IUFindOnSwitchIndex(&AlignmentSubsystemMathPluginsV);
        if (NewPlugin != CurrentPlugin)
        {
            // New plugin requested
            // Unload old plugin if required
            if (0 != CurrentPlugin)
            {
                typedef void Destroy_t(MathPlugin *);
                Destroy_t* Destroy = (Destroy_t*)dlsym(LoadedMathPluginHandle, "Destroy");
                if (NULL != Destroy)
                {
                    Destroy(pLoadedMathPlugin);
                    pLoadedMathPlugin = NULL;
                    if (0 == dlclose(LoadedMathPluginHandle))
                    {
                        LoadedMathPluginHandle = NULL;

                    }
                    else
                    {
                        IDLog("MathPluginManagement - dlclose failed on loaded plugin - %s\n", dlerror());
                        AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
                    }
                }
                else
                {
                    IDLog("MathPluginManagement - cannot get Destroy function - %s\n", dlerror());
                    AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
                }
            }
            // Load the requested plugin if required
            if (0 != NewPlugin)
            {
                std::string PluginPath(MathPluginFiles[NewPlugin - 1]);
                if (NULL != (LoadedMathPluginHandle = dlopen(PluginPath.c_str(), RTLD_NOW)))
                {
                    typedef MathPlugin* Create_t();
                    Create_t* Create = (Create_t*)dlsym(LoadedMathPluginHandle, "Create");
                    if (NULL != Create)
                    {
                        pLoadedMathPlugin = Create();
                        IUSaveText(&AlignmentSubsystemCurrentMathPlugin, PluginPath.c_str());
                    }
                    else
                    {
                        IDLog("MathPluginManagement - cannot get Create function - %s\n", dlerror());
                        AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
                    }
                }
                else
                {
                    IDLog("MathPluginManagement - cannot load plugin %s error %s\n", PluginPath.c_str(), dlerror());
                    AlignmentSubsystemMathPluginsV.s = IPS_ALERT;
                }
            }
            else
            {
                // It is in built plugin just set up the pointers
                pLoadedMathPlugin = &BuiltInPlugin;
            }
        }

        //  Update client
        IDSetSwitch(&AlignmentSubsystemMathPluginsV, NULL);
    }
    else if (strcmp(name, AlignmentSubsystemMathPluginInitialiseV.name) == 0)
    {
        AlignmentSubsystemMathPluginInitialiseV.s = IPS_OK;
        IUResetSwitch(&AlignmentSubsystemMathPluginInitialiseV);
        //  Update client display
        IDSetSwitch(&AlignmentSubsystemMathPluginInitialiseV, NULL);

        // Initialise or reinitialise the current math plugin
        Initialise(CurrentInMemoryDatabase);
    }
    else if (strcmp(name, AlignmentSubsystemActiveV.name) == 0)
    {
        AlignmentSubsystemActiveV.s=IPS_OK;
        if (0 == IUUpdateSwitch(&AlignmentSubsystemActiveV, states, names, n))
            //  Update client
            IDSetSwitch(&AlignmentSubsystemActiveV, NULL);
    }
}
Beispiel #8
0
DataIndices::DataIndices( const unsigned& x, const unsigned& y, const unsigned& z ) {
    Initialise( x, y, z );
}
Beispiel #9
0
DataIndices::DataIndices( const unsigned& x, const unsigned& y ) {
    Initialise( x, y, 0 );
}
Beispiel #10
0
void VideoVisualSpectrum::Draw(const QRect &area, MythPainter *painter,
                               QPaintDevice* device)
{
    if (m_disabled)
        return;

    mutex()->lock();
    VisualNode *node = GetNode();

    if (area.isEmpty() || !painter)
    {
        mutex()->unlock();
        return;
    }

    if (!Initialise(area))
    {
        mutex()->unlock();
        return;
    }

    uint i = 0;
    if (node)
    {
        i = node->length;
        fast_real_set_from_short(lin, node->left, node->length);
        if (node->right)
            fast_real_set_from_short(rin, node->right, node->length);
    }
    mutex()->unlock();

    fast_reals_set(lin + i, rin + i, 0, FFTW_N - i);
    fftw_execute(lplan);
    fftw_execute(rplan);

    double magL, magR, tmp;
    double falloff = (((double)SetLastUpdate()) / 40.0) * m_falloff;
    if (falloff < 0.0)
        falloff = 0.0;
    if (falloff > 2048.0)
        falloff = 2048.0;
    for (int l = 0, r = m_scale.range(); l < m_scale.range(); l++, r++)
    {
        int index = m_scale[l];
        magL = (log(sq(real(lout[index])) + sq(real(lout[FFTW_N - index]))) - 22.0) *
               m_scaleFactor;
        magR = (log(sq(real(rout[index])) + sq(real(rout[FFTW_N - index]))) - 22.0) *
               m_scaleFactor;

        if (magL > m_range)
            magL = 1.0;

        if (magL < m_magnitudes[l])
        {
            tmp = m_magnitudes[l] - falloff;
            if (tmp < magL)
                tmp = magL;
            magL = tmp;
        }

        if (magL < 1.0)
            magL = 1.0;

        if (magR > m_range)
            magR = 1.0;

        if (magR < m_magnitudes[r])
        {
            tmp = m_magnitudes[r] - falloff;
            if (tmp < magR)
                tmp = magR;
            magR = tmp;
        }

        if (magR < 1.0)
            magR = 1.0;

        m_magnitudes[l] = magL;
        m_magnitudes[r] = magR;
    }

    DrawPriv(painter, device);
}
Beispiel #11
0
CSensorDataFilter::CSensorDataFilter()
{
	Initialise();
}
CColourPopup::CColourPopup()
{
    Initialise();
}
Beispiel #13
0
int main(int argc, char *argv[])
{
   char *datafn, *s;
   int nSeg;
   void Initialise(void);
   void LoadFile(char *fn);
   void EstimateModel(void);
   void SaveModel(char *outfn);
   
   if(InitShell(argc,argv,hinit_version,hinit_vc_id)<SUCCESS)
      HError(2100,"HInit: InitShell failed");
   InitMem();   InitLabel();
   InitMath();  InitSigP();
   InitWave();  InitAudio();
   InitVQ();    InitModel();
   if(InitParm()<SUCCESS)  
      HError(2100,"HInit: InitParm failed");
   InitTrain(); InitUtil();

   if (!InfoPrinted() && NumArgs() == 0)
      ReportUsage();
   if (NumArgs() == 0) Exit(0);
   SetConfParms();

   CreateHMMSet(&hset,&gstack,FALSE);
   while (NextArg() == SWITCHARG) {
      s = GetSwtArg();
      if (strlen(s)!=1) 
         HError(2119,"HInit: Bad switch %s; must be single letter",s);
      switch(s[0]){
      case 'e':
         epsilon = GetChkedFlt(0.0,1.0,s); break;
      case 'g':
         ignOutVec = FALSE; break;
      case 'i':
         maxIter = GetChkedInt(0,100,s); break;
      case 'l':
         if (NextArg() != STRINGARG)
            HError(2119,"HInit: Segment label expected");
         segLab = GetStrArg();
         break;
      case 'm':
         minSeg = GetChkedInt(1,1000,s); break;
      case 'n':
         newModel = FALSE; break;
      case 'o':
         outfn = GetStrArg();
         break;
      case 'u':
         SetuFlags(); break;
      case 'v':
         minVar = GetChkedFlt(0.0,10.0,s); break;
      case 'w':
         mixWeightFloor = MINMIX * GetChkedFlt(0.0,100000.0,s); 
         break;
      case 'B':
         saveBinary = TRUE;
         break;
      case 'F':
         if (NextArg() != STRINGARG)
            HError(2119,"HInit: Data File format expected");
         if((dff = Str2Format(GetStrArg())) == ALIEN)
            HError(-2189,"HInit: Warning ALIEN Data file format set");
         break;
      case 'G':
         if (NextArg() != STRINGARG)
            HError(2119,"HInit: Label File format expected");
         if((lff = Str2Format(GetStrArg())) == ALIEN)
            HError(-2189,"HInit: Warning ALIEN Label file format set");
         break;
      case 'H':
         if (NextArg() != STRINGARG)
            HError(2119,"HInit: HMM macro file name expected");
         AddMMF(&hset,GetStrArg());
         break;
      case 'I':
         if (NextArg() != STRINGARG)
            HError(2119,"HInit: MLF file name expected");
         LoadMasterFile(GetStrArg());
         break;
      case 'L':
         if (NextArg()!=STRINGARG)
            HError(2119,"HInit: Label file directory expected");
         labDir = GetStrArg(); break;
      case 'M':
         if (NextArg()!=STRINGARG)
            HError(2119,"HInit: Output macro file directory expected");
         outDir = GetStrArg();
         break;
      case 'T':
         if (NextArg() != INTARG)
            HError(2119,"HInit: Trace value expected");
         trace = GetChkedInt(0,01777,s);
         break;
      case 'X':
         if (NextArg()!=STRINGARG)
            HError(2119,"HInit: Label file extension expected");
         labExt = GetStrArg(); break;
      default:
         HError(2119,"HInit: Unknown switch %s",s);
      }
   }
   if (NextArg()!=STRINGARG)
      HError(2119,"HInit: source HMM file name expected");
   hmmfn = GetStrArg();
   Initialise();
   do {
      if (NextArg()!=STRINGARG)
         HError(2119,"HInit: training data file name expected");
      datafn = GetStrArg();
      LoadFile(datafn);
   } while (NumArgs()>0);
   nSeg = NumSegs(segStore);
   if (nSeg < minSeg)
      HError(2121,"HInit: Too Few Observation Sequences [%d]",nSeg);
   if (trace&T_TOP) {
      printf("%d Observation Sequences Loaded\n",nSeg);
      fflush(stdout);
   }
   EstimateModel();
   SaveModel(outfn);
   if (trace&T_TOP)
      printf("Output written to directory %s\n",
             outDir==NULL?"current":outDir);
   
   InitMem();   InitLabel();
   InitMath();  InitSigP();
   InitWave();  InitAudio();
   InitVQ();    InitModel();
   if(InitParm()<SUCCESS)  
      HError(2100,"HInit: InitParm failed");
   InitTrain(); InitUtil();
   
   ResetUtil();
   ResetTrain();
   ResetParm();
   ResetModel();
   ResetVQ();
   ResetAudio();
   ResetWave();
   ResetSigP();
   ResetMath();
   ResetLabel();
   ResetMem();
   ResetShell();
   
   Exit(0);
   return (0);          /* never reached -- make compiler happy */
}
Beispiel #14
0
Logger::Logger()
{
	Initialise();
}
int main(int argc, char *argv[])
{
	MPI_Comm		CommWorld;
	int			rank;
	int			procCount;
	int			procToWatch;
	Dictionary*		dictionary;
	ExtensionManager_Register*	extensionMgr_Register;
	Topology*		nTopology;
	ElementLayout*		eLayout;
	NodeLayout*		nLayout;
	MeshDecomp*		decomp;
	MeshLayout*		ml;
	Mesh*			mesh;
	Stream*			stream;

	
	/* Initialise MPI, get world info */
	MPI_Init(&argc, &argv);
	MPI_Comm_dup( MPI_COMM_WORLD, &CommWorld );
	MPI_Comm_size(CommWorld, &procCount);
	MPI_Comm_rank(CommWorld, &rank);

	Base_Init( &argc, &argv );
	
	DiscretisationGeometry_Init( &argc, &argv );
	DiscretisationShape_Init( &argc, &argv );
	DiscretisationMesh_Init( &argc, &argv );

	stream = Journal_Register (Info_Type, "myStream");
	procToWatch = argc >= 2 ? atoi(argv[1]) : 0;
	
	dictionary = Dictionary_New();
	Dictionary_Add( dictionary, "rank", Dictionary_Entry_Value_FromUnsignedInt( rank ) );
	Dictionary_Add( dictionary, "numProcessors", Dictionary_Entry_Value_FromUnsignedInt( procCount ) );
	Dictionary_Add( dictionary, "meshSizeI", Dictionary_Entry_Value_FromUnsignedInt( 7 ) );
	Dictionary_Add( dictionary, "meshSizeJ", Dictionary_Entry_Value_FromUnsignedInt( 7 ) );
	Dictionary_Add( dictionary, "meshSizeK", Dictionary_Entry_Value_FromUnsignedInt( 7 ) );
	Dictionary_Add( dictionary, "allowUnusedCPUs", Dictionary_Entry_Value_FromBool( False ) );
	Dictionary_Add( dictionary, "allowPartitionOnNode", Dictionary_Entry_Value_FromBool( True ) );
	Dictionary_Add( dictionary, "allowUnbalancing", Dictionary_Entry_Value_FromBool( False ) );
	Dictionary_Add( dictionary, "shadowDepth", Dictionary_Entry_Value_FromUnsignedInt( 1 ) );
	
	nTopology = (Topology*)IJK6Topology_New( "IJK6Topology", dictionary );
	eLayout = (ElementLayout*)ParallelPipedHexaEL_New( "PPHexaEL", 3, dictionary );
	nLayout = (NodeLayout*)CornerNL_New( "CornerNL", dictionary, eLayout, nTopology );
	decomp = (MeshDecomp*)HexaMD_New( "HexaMD", dictionary, MPI_COMM_WORLD, eLayout, nLayout );
	ml = MeshLayout_New( "MeshLayout", eLayout, nLayout, decomp );
	
	extensionMgr_Register = ExtensionManager_Register_New();
	mesh = Mesh_New( "Mesh", ml, sizeof(Node), sizeof(Element), extensionMgr_Register, dictionary );
	
	mesh->buildNodeLocalToGlobalMap = True;
	mesh->buildNodeDomainToGlobalMap = True;
	mesh->buildNodeGlobalToLocalMap = True;
	mesh->buildNodeGlobalToDomainMap = True;
	mesh->buildNodeNeighbourTbl = True;
	mesh->buildNodeElementTbl = True;
	mesh->buildElementLocalToGlobalMap = True;
	mesh->buildElementDomainToGlobalMap = True;
	mesh->buildElementGlobalToDomainMap = True;
	mesh->buildElementGlobalToLocalMap = True;
	mesh->buildElementNeighbourTbl = True;
	mesh->buildElementNodeTbl = True;
	
	Build( mesh, 0, False );
	Initialise(mesh, 0, False );
	

	
	if (rank == procToWatch)
	{
		Node_Index				currElementNodesCount=0;	
		Node_Index*         	currElementNodes = NULL;
		Element_Index          	element_dI = 0;
		Node_Index             	refNode_eI = 0;
		Node_Index				node_Diagonal = 0;
		Node_Index				node_Diagonal_gI = 0;
		
		// only use this while setting up the test
		//Print(mesh, stream);
				
		// Some tests involving RegularMeshUtils_GetDiagOppositeAcrossElementNodeIndex()
		
		
		for (element_dI=0; element_dI < mesh->elementDomainCount; element_dI++) {
			
			currElementNodes = mesh->elementNodeTbl[element_dI];
			currElementNodesCount = mesh->elementNodeCountTbl[element_dI];
			
			for (refNode_eI = 0; refNode_eI < currElementNodesCount; refNode_eI++ ) {
				
				node_Diagonal = RegularMeshUtils_GetDiagOppositeAcrossElementNodeIndex(mesh, element_dI, 
					currElementNodes[refNode_eI]) ;
				node_Diagonal_gI = Mesh_NodeMapDomainToGlobal( mesh, node_Diagonal );
				//print message stating: Element #, curr node #, diag opp node #
				printf("Element #: %d, Current Node #: %d, Diagonal Node #: %d, (%d) \n",
					element_dI, currElementNodes[refNode_eI], node_Diagonal, node_Diagonal_gI);
				
			}
		}	
	}
	
	Stg_Class_Delete(mesh);
	Stg_Class_Delete(ml);
	Stg_Class_Delete(decomp);
	Stg_Class_Delete(nLayout);
	Stg_Class_Delete(eLayout);
	Stg_Class_Delete( nTopology );
	Stg_Class_Delete(dictionary);
	
	DiscretisationMesh_Finalise();
	DiscretisationShape_Finalise();
	DiscretisationGeometry_Finalise();
	
	Base_Finalise();
	
	/* Close off MPI */
	MPI_Finalize();
	
	return 0; /* success */
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
tMFDDigitalDataManager::tMFDDigitalDataManager(
    tISettingsWriterFactory& settingsWriterFactory,
    tNMEA0183Settings* pNMEA0183Settings,
    tDigitalDataConfig& digitalDataConfig,
    tNDP2k& ndp2k,
    tNDP2kDeviceSelection& ndp2kDeviceSelection,
    tConvert& convert,
    tLoran& loran,
    tUnitsSettings& unitsSettings,
    tHAL& hal,
    tGpsInternalProxy& gpsInternalProxy,
    tSerialPortManager& serialPortManager,
    tSerialSettings& serialSettings,
    tNetworkMonitor& networkMonitor,
    bool createTestAppNetworkProxy )
: tDigitalDataManager(
    settingsWriterFactory,
    pNMEA0183Settings,
    digitalDataConfig,
    ndp2k,
    hal,
    ndp2kDeviceSelection,
    convert,
    &loran,
    unitsSettings)
, m_GpsInternalProxy(gpsInternalProxy)
, m_SerialPortManager(serialPortManager)
, m_NetworkMonitor(networkMonitor)
, m_CreateTestAppNetworkProxy(createTestAppNetworkProxy)
{
    if  (
        (m_DigitalDataConfig.TimePlotsAllowed()) ||
        (m_DigitalDataConfig.WindPlotsAllowed())
        )
    {
        tDigitalTimePlotDataManager::CreateInstance();
    }

    // Create and register the MFD specialized digital data engines
    {
        { // Navigation Data Engine
            tNavigationDataEngine::tConfig config =
            {
                tNavigationDataEngine::tSailingFeaturesAllowed( m_DigitalDataConfig.SailingFeaturesAllowed() )
            };

            m_pNavigationDataEngine = new tNavigationDataEngine(config);

            // Connect the NavigationDataEngine to UDB
            Connect( UDB::GetUDBWpRtDB()->asQObject(), SIGNAL( DBUpdated( const tWaypoint&, tUDBCmdType ) ), m_pNavigationDataEngine, SLOT( OnWaypointUpdated( const tWaypoint&, tUDBCmdType ) ) );
            Connect( UDB::GetUDBWpRtDB()->asQObject(), SIGNAL( DBUpdated( const tRoute&, tUDBCmdType ) ), m_pNavigationDataEngine, SLOT( OnRouteUpdated( const tRoute&, tUDBCmdType ) ) );
            Connect( UDB::GetUDBWpRtDB()->asQObject(), SIGNAL( DBReloaded() ), m_pNavigationDataEngine, SLOT( OnDbReloaded() ) );

            Connect( UDB::GetUDBVariablesDB()->asQObject(), SIGNAL( NavVariablesChanged( const quint64&, const QVariant ) ), m_pNavigationDataEngine, SLOT( OnUDBVariablesChanged( const quint64&, const QVariant ) ) );
            Connect( UDB::GetUDBVariablesDB()->asQObject(), SIGNAL( DBReloaded() ), m_pNavigationDataEngine, SLOT( OnVariablesReloaded() ) );
            m_pNavigationDataEngine->OnVariablesReloaded(); // check if already navigating at startup

            // Inform interested parties whether we are navigating or not
            Connect( m_pNavigationDataEngine, SIGNAL(NavigatingChanged(bool)), m_pAutoGpsDataEngine, SLOT(SetNavigating(bool)) );
            m_pAutoGpsDataEngine->SetNavigating(m_pNavigationDataEngine->Navigating());

            RegisterDataEngine( DATA_ENGINE_NAVIGATION, m_pNavigationDataEngine );
        }

        { // NMEA0183
            QList<tSerialPort::eComPort> serialPorts;
            for(unsigned int i = 0; i < hal.IOInterface()->NumSerialPorts(); i++)
            {
                serialPorts << static_cast<tSerialPort::eComPort>(hal.IOInterface()->SerialPortNumber(i+1));
            }

            tNMEA0183::tConfig config =
            {
                tUtc                            (boost::bind(&tSystemDateTime::CurrentDateTimeUtc, hal.SystemDateTime())),
                tGlcSentence                    (boost::bind(&tLoran::GetGlcSentence, &loran, _1)),
                hal.GPSChipset(),
                tNMEA0183::tHaveIgps            (hal.IOInterface()->HaveIGPS()),
                static_cast<tSerialPort::eComPort>(hal.IOInterface()->SerialPortNumber(0)),
                &gpsInternalProxy,
                serialPorts,
                tNMEA0183::tNMEA0183OverTcpAllowed(m_DigitalDataConfig.NMEA0183OverTcpAllowed()),
                Get0183OutTcpManager(),
            };

            m_pNMEA0183 = new tNMEA0183(
                serialPortManager,
                *m_pNMEA0183Settings,
                serialSettings,
                *m_pNavigationDataEngine,
                tHAL::Instance()->IOInterface(),
                config);

            RegisterDataEngine( DATA_ENGINE_NMEA183, m_pNMEA0183 );

            Connect(
                &m_DigitalDataConfig, 
                SIGNAL(SimulatorEnabledChanged(bool)), 
                m_pNMEA0183, 
                SLOT(SetSimulatorEnabled(bool)) );

            Connect(
                &m_DigitalDataConfig, 
                SIGNAL(LocalTimeOffsetChanged(int)), 
                m_pNMEA0183, 
                SLOT(SetLocalTimeOffset(int)) );

            Connect(
                m_pNMEA0183,
                SIGNAL(RequestExitAppRestart()),
                this,
                SIGNAL(RequestExitAppRestart()));

            Connect(
                m_pNMEA0183,
                SIGNAL(RequestExitTestMode()),
                this,
                SIGNAL(RequestExitTestMode()));

            Connect(
                m_pNMEA0183,
                SIGNAL(RequestExitBurnin()),
                this,
                SIGNAL(RequestExitBurnin()));


            m_pNMEA0183->SetSimulatorEnabled(m_DigitalDataConfig.SimulatorEnabled());
            m_pNMEA0183->SetLocalTimeOffset(m_DigitalDataConfig.LocalTimeOffset());
        }

        {
            m_pSimulateDataEngine = new tSimulateDataEngine(*m_pNavigationDataEngine, m_DigitalDataConfig.SailingFeaturesAllowed());
            RegisterDataEngine( DATA_ENGINE_SIMULATE, m_pSimulateDataEngine );
            QVector<tDataType> simulatedTypes = m_pSimulateDataEngine->SimulatedDataTypes();
            m_pActiveDataEngine->SetSimulationTypes(simulatedTypes);
        }

        {
           int numEngines = tDigitalData::NumInstances(DATA_CATEGORY_ENGINE);
           int numTanks = tDigitalData::NumInstances(DATA_CATEGORY_FUEL_TANK);

            m_pFuelManagementEngine = new tFuelManagementEngine(numEngines, numTanks, *m_pFuelSettings);
            Connect(m_pSourceSelection, SIGNAL(NumInstancesChanged(int)), m_pFuelManagementEngine, SLOT(OnNumberInstancesChanged(int)));

            RegisterDataEngine( DATA_ENGINE_FUEL_MANAGEMENT, m_pFuelManagementEngine );
            RegisterDataEngine( DATA_ENGINE_VESSEL_FUEL_MANAGEMENT, m_pFuelManagementEngine );

        }
    }

    // Connection for tNMEA0183
    Connect( m_pNMEA0183, SIGNAL( UtcTimeAndDateUpdated( const tDataId&, const QTime&, const QDate& ) ),
             this, SLOT( OnUtcTimeAndDateUpdated(const tDataId&, const QTime&, const QDate& ) ) );

    // Connect signal to be notified when a 0183 MOB is received
    Connect(m_pNMEA0183, SIGNAL(MOBReceived(const tRCoord&, QString)), this, SIGNAL(MOBReceived(const tRCoord&, QString)));

    // Create the virtual device objects
    {
        char iGpsSource;
        if (m_pNMEA0183->GetIGPSSource(&iGpsSource))
        {
            m_pIGPSVirtualDevice = new tInternalGPSVirtualDevice(
                        iGpsSource,
                        m_NDP2k,
                        *m_pNMEA0183Settings,
                        *m_pNDP2kDataEngine );
        }

        if(m_DigitalDataConfig.Ndp2kNavVirtualDeviceAllowed() == true)
        {
            tNavigationVirtualDevice::tConfig config =
            {
                tNavigationVirtualDevice::tSailingFeaturesAllowed(m_DigitalDataConfig.SailingFeaturesAllowed())
            };
            m_pNavigationVirtualDevice = new tNavigationVirtualDevice(
                m_NDP2k,
                *m_pNavigationDataEngine,
                *m_pNDP2kDataEngine,
                config);
            Connect( &m_DigitalDataConfig, SIGNAL(LocalTimeOffsetChanged(int)), m_pNavigationVirtualDevice, SLOT(SetLocalTimeOffset(int)) );
            m_pNavigationVirtualDevice->SetLocalTimeOffset(m_DigitalDataConfig.LocalTimeOffset());
            m_pNavigationVirtualDevice->Initialise();
        }

        // NMEA0183 Virtual Device(s)
        QList<char> nmea0183Sources = m_pNMEA0183->Get0183Sources();
        if(nmea0183Sources.size() > 0) // Port 1
        {
            m_pNMEA0183VirtualDevice1 = CreateAndConnectNMEA0183VirtualDevice(nmea0183Sources[0], tNDP2k::TxDeviceNmea0183Port1);
        }
        if(nmea0183Sources.size() > 1) // Port 2
        {
            m_pNMEA0183VirtualDevice2 = CreateAndConnectNMEA0183VirtualDevice(nmea0183Sources[1], tNDP2k::TxDeviceNmea0183Port2);
        }
    }
Tree::Tree()
{
    Initialise();
}
Beispiel #18
0
/* main: */
int main(int argc, char *argv[])
{
   char *s;
   char fname[MAXSTRLEN];

   InitShell(argc, argv, hmgetool_version, hmgetool_vc_id);
   InitMem();
   InitMath();
   InitSigP();
   InitWave();
   InitLabel();
   InitModel();
   InitTrain();
   InitParm();
   InitUtil();
   InitFB();
   InitGen();
   InitAdapt(&xfInfo, NULL);
   InitMTrain();

   /* process argument */
   if (NumArgs() == 0)
      ReportUsage();
   CreateHeap(&hmmStack, "Model Stack", MSTAK, 1, 1.0, 80000, 4000000);
   CreateHeap(&orighmmStack, "Model Stack", MSTAK, 1, 1.0, 80000, 4000000);
   CreateHeap(&accStack, "Acc Stack", MSTAK, 1, 1.0, 80000, 400000);
   CreateHeap(&genStack, "Gen Stack", MSTAK, 1, 1.0, 80000, 400000);
   CreateHeap(&mgeStack, "MGE Train Stack", MSTAK, 1, 1.0, 80000, 400000);

   SetConfParms();
   CreateHMMSet(&hset, &hmmStack, TRUE);
   CreateHMMSet(&orighset, &orighmmStack, TRUE);

   statInfo = (MTStatInfo *) New(&gstack, sizeof(MTStatInfo));
   memset(statInfo, 0, sizeof(MTStatInfo));

   genInfo = (GenInfo *) New(&genStack, sizeof(GenInfo));
   memset(genInfo, 0, sizeof(GenInfo));
   genInfo->hset = &hset;
   genInfo->genMem = &genStack;

   mtInfo = (MgeTrnInfo *) New(&mgeStack, sizeof(MgeTrnInfo));
   memset(mtInfo, 0, sizeof(MgeTrnInfo));
   mtInfo->genInfo = genInfo;
   mtInfo->statInfo = statInfo;
   mtInfo->hset = &hset;
   mtInfo->orighset = &orighset;
   mtInfo->mgeMem = &mgeStack;

   while (NextArg() == SWITCHARG) {
      s = GetSwtArg();
      if (strlen(s) != 1)
         HError(6601, "HMgeTool: Bad switch %s; must be single letter", s);
      switch (s[0]) {
      case 'a':
         nMaxBAIter = GetChkedInt(1, 1000, s);
         nMaxBALen = GetChkedInt(1, 1000, s);
         break;
      case 'b':
         mtInfo->bBoundAdj = TRUE;
         nBAEndIter = GetChkedInt(0, 1000, s);
         nBoundAdjWin = GetChkedInt(1, 1000, s);
         break;
      case 'c':
         outProcData = TRUE;
         break;
      case 'd':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM definition directory expected");
         hmmDir = GetStrArg();
         break;
      case 'e':
         mtInfo->bStepLimit = TRUE;
         break;
      case 'f':
         frameRate = (HTime) GetChkedFlt(0.0, 10000000.0, s);
         break;
      case 'g':
         mtInfo->bMVar = TRUE;
         break;
      case 'i':
         startIter = GetChkedInt(0, 1000, s);
         endIter = GetChkedInt(startIter, 1000, s);
         break;
      case 'j':
         funcType = GetChkedInt(0, 2, s);
         mtInfo->funcType = funcType;
         break;
      case 'l':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: Label file output directory expected");
         outLabDir = GetStrArg();
         break;
      case 'o':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM file extension expected");
         outExt = GetStrArg();
         break;
      case 'p':
         A_STEP = GetChkedFlt(0.0, 10000000.0, s);
         B_STEP = GetChkedFlt(0.0, 10000000.0, s);
         break;
      case 'r':
         mtInfo->bOrigHmmRef = TRUE;
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM macro file name expected");
         s = GetStrArg();
         AddMMF(&orighset, s);
         break;
      case 's':                /* updating scale file */
         scalefn = GetStrArg();
         break;
      case 'u':
         SetuFlags();
         break;
      case 'v':
         MSDthresh = GetChkedFlt(0.0, 1.0, s);
         break;
      case 'w':
         fGVDistWght = GetChkedFlt(0.0, 1000.0, s);
         break;
      case 'x':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM file extension expected");
         hmmExt = GetStrArg();
         break;
      case 'B':
         inBinary = TRUE;
         break;
      case 'G':
         mtInfo->nGainStreamIndex = GetChkedInt(1, SMAX, s);
         mtInfo->nGainDimIndex = GetChkedInt(1, 1000, s);
         if (NextArg() == FLOATARG || NextArg() == INTARG)
            mtInfo->fGainWghtComp = GetChkedFlt(-10000.0, 1000000.0, s);
         break;
      case 'H':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM macro file name expected");
         mmfFn = GetStrArg();
         AddMMF(&hset, mmfFn);
         break;
      case 'I':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: MLF file name expected");
         LoadMasterFile(GetStrArg());
         break;
      case 'J':                /* regression class and tree */
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM regression class/tree file name expected");
         s = GetStrArg();
         AddMMF(&hset, s);
         AddMMF(&orighset, s);
         break;
      case 'K':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: HMM transform file name expected");
         xformfn = GetStrArg();
         break;
      case 'L':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: Label file directory expected");
         labDir = GetStrArg();
         break;
      case 'M':
         if (NextArg() != STRINGARG)
            HError(6601, "HMgeTool: Output macro file directory expected");
         outDir = GetStrArg();
         break;
      case 'T':
         trace = GetChkedInt(0, 0100000, s);
         break;
      case 'X':
         if (NextArg() != STRINGARG)
            HError(2319, "HMGenS: Label file extension expected");
         labExt = GetStrArg();
         break;
      default:
         HError(6601, "HMgeTool: Unknown switch %s", s);
      }
   }

   if (NextArg() != STRINGARG)
      HError(6601, "HMgeTool: file name of model list expected");
   hmmListFn = GetStrArg();
   Initialise();

   if (funcType == MGE_EVAL) {
      PerformMgeEval();
   } else if (funcType == MGE_TRAIN) {
      PerformMgeTrain();
      if (endIter > 0 && bMgeUpdate) {
         /* output HMM files */
         ConvDiagC(&hset, TRUE);
         SaveHMMSet(&hset, outDir, outExt, NULL, inBinary);
      }
   } else if (funcType == MGE_ADAPT) {
      PerformMgeAdapt();
      if (endIter > 0 && bMgeUpdate) {
         MakeFN(xformfn, outDir, NULL, fname);
         SaveOneXForm(&hset, hset.curXForm, fname, FALSE);
      }
   }

   ResetHeap(&hmmStack);
   ResetHeap(&orighmmStack);
   ResetHeap(&accStack);
   ResetHeap(&genStack);
   ResetHeap(&mgeStack);

   return 0;
}
Beispiel #19
0
int main(int argc, char *argv[])
{
   char *datafn, *s;
   int stream = 0;
   void Initialise(char *datafn);
   void LoadFile(char *fn);
   void CalcMeanCov(Sequence seq[], int s);
   void ClusterVecs(Sequence seq[], int s);
   void WriteVQTable(ClusterSet *cs[], char *fn);  

   if(InitShell(argc,argv,hquant_version,hquant_vc_id)<SUCCESS)
      HError(2500,"HQuant: InitShell failed");

   InitMem();   InitLabel();
   InitMath();  InitSigP();
   InitWave();  InitAudio();
   InitVQ();    InitModel();
   if(InitParm()<SUCCESS)  
      HError(2500,"HQuant: InitParm failed");
   InitTrain();

   if (!InfoPrinted() && NumArgs() == 0)
      ReportUsage();
   if (NumArgs() == 0) Exit(0);
   SetConfParms();
   InitStreamVars();

   while (NextArg() == SWITCHARG) {
      s = GetSwtArg();
      if (strlen(s)!=1) 
         HError(2519,"HQuant: Bad switch %s; must be single letter",s);
      switch(s[0]){
      case 'd':
         if ( ck != NULLC) HError(2519,"HQuant: Specify one of -d or -f, not both");
         ck = INVDIAGC;
         break;
      case 'f':
         if ( ck != NULLC) HError(2519,"HQuant: Specify one of -d or -f, not both");
         ck = FULLC;
         break;
      case 'g':
         globClustVar = TRUE;
         break;
      case 'l':
         if (NextArg() != STRINGARG)
            HError(2519,"HQuant: Segment label expected");
         segLab = GetStrArg();
         break;
      case 'n':
         if (NextArg() != INTARG)
            HError(2519,"HQuant: Stream number expected");
         stream = GetChkedInt(1,SMAX,s);
         if (NextArg() != INTARG)
            HError(2519,"HQuant: Codebook size expected");
         cbSizes[stream]= GetChkedInt(1,32768,s);
         break;
      case 's':
         if (NextArg() != INTARG)
            HError(2519,"HQuant: Number of streams expected");
         swidth[0] = GetChkedInt(1,SMAX,s);
         break;
      case 't':
         tType = binTree;
         break;
      case 'w':
         if (NextArg() != INTARG)
            HError(2519,"HQuant: Stream number expected");
         stream = GetChkedInt(1,SMAX,s);
         if(swidth[0] < stream) swidth[0] = stream;
         widthSet = TRUE;
         if (NextArg() != INTARG)
            HError(2519,"HQuant: Stream width expected");
         swidth[stream]= GetChkedInt(1,256,s);
         break;
      case 'F':
         if (NextArg() != STRINGARG)
            HError(2519,"HQuant: Data File format expected");
         if((dff = Str2Format(GetStrArg())) == ALIEN)
            HError(-2589,"HQuant: Warning ALIEN Data file format set");
         break;
      case 'G':
         if (NextArg() != STRINGARG)
            HError(2519,"HQuant: Label File format expected");
         if((lff = Str2Format(GetStrArg())) == ALIEN)
            HError(-2589,"HQuant: Warning ALIEN Label file format set");
         break;
      case 'I':
         if (NextArg() != STRINGARG)
            HError(2519,"HQuant: MLF file name expected");
         LoadMasterFile(GetStrArg());
         break;
      case 'L':
         if (NextArg()!=STRINGARG)
            HError(2519,"HQuant: Label file directory expected");
         labDir = GetStrArg();
         break;
      case 'T':
         if (NextArg() != INTARG)
            HError(2519,"HQuant: Trace value expected");
         trace = GetChkedInt(0,077,s); 
         break;
      case 'X':
         if (NextArg()!=STRINGARG)
            HError(2519,"HQuant: Label file extension expected");
         labExt = GetStrArg();
         break;
      default:
         HError(2519,"HQuant: Unknown switch %s",s);
      }
   }
   if (NextArg()!=STRINGARG)
      HError(2519,"HQuant: Output VQ table file name expected");
   vqfn = GetStrArg();

   if (NextArg()!=STRINGARG)
      HError(2519,"HQuant: Training data file name expected");
   datafn = GetStrArg();
   Initialise(datafn);
   LoadFile(datafn);
   while (NumArgs()>0) {
      if (NextArg()!=STRINGARG) 
         HError(2519,"HQuant: Training data file name expected");
      datafn = GetStrArg();
      LoadFile(datafn);
   }
   
   for (stream=1;stream<=swidth[0];stream++){
      if (trace&T_TOP)
         printf("%s-clustering data for stream %d (width %d)\n",
                (tType==linTree)?"Flat":"Tree",stream,swidth[stream]);
      CalcMeanCov(dSeq,stream);
      ClusterVecs(dSeq,stream);
   }
   WriteVQTable(cs,vqfn);

   ResetTrain();
   ResetParm();
   ResetModel();
   ResetVQ();
   ResetAudio();
   ResetWave();
   ResetSigP();
   ResetMath();
   ResetLabel();
   ResetMem();
   ResetShell();
   
   Exit(0);
   return (0);          /* never reached -- make compiler happy */
}
Beispiel #20
0
/* SetConfParms: set conf parms relevant to HCompV  */

void SetConfParms(void)

{

   int i;

   Boolean b;

   double f;

   char buf[MAXSTRLEN];

   

   nParm = GetConfig("HEREST", TRUE, cParm, MAXGLOBS);

   if (nParm>0) {

      if (GetConfInt(cParm,nParm,"TRACE",&i)) trace = i;

      if (GetConfFlt(cParm,nParm,"VARFLOORPERCENTILE",&f)) varFloorPercent = f;

      if (GetConfBool(cParm,nParm,"SAVEBINARY",&b)) saveBinary = b;

      if (GetConfBool(cParm,nParm,"BINARYACCFORMAT",&b)) ldBinary = b;

      /* 2-model reestimation alignment model set */

      if (GetConfStr(cParm,nParm,"ALIGNMODELMMF",buf)) {

          strcpy(al_hmmMMF,buf); al_hmmUsed = TRUE;

      }

      if (GetConfStr(cParm,nParm,"ALIGNHMMLIST",buf)) {

          strcpy(al_hmmLst,buf); al_hmmUsed = TRUE;

      }

      /* allow multiple individual model files */

      if (GetConfStr(cParm,nParm,"ALIGNMODELDIR",buf)) {

          strcpy(al_hmmDir,buf); al_hmmUsed = TRUE;

      }

      if (GetConfStr(cParm,nParm,"ALIGNMODELEXT",buf)) {

          strcpy(al_hmmExt,buf); al_hmmUsed = TRUE;

      }

      if (GetConfStr(cParm,nParm,"ALIGNXFORMEXT",buf)) {

         xfInfo.alXFormExt = CopyString(&hmmStack,buf);

      }

      if (GetConfStr(cParm,nParm,"ALIGNXFORMDIR",buf)) {

         xfInfo.alXFormDir = CopyString(&hmmStack,buf);

      }

      if (GetConfStr(cParm,nParm,"INXFORMMASK",buf)) {

         xfInfo.inSpkrPat = CopyString(&hmmStack,buf);

      }

      if (GetConfStr(cParm,nParm,"PAXFORMMASK",buf)) {

         xfInfo.paSpkrPat = CopyString(&hmmStack,buf);

      }

      if (GetConfStr(cParm,nParm,"LABFILEMASK",buf)) {

         labFileMask = (char*)malloc(strlen(buf)+1); 

         strcpy(labFileMask, buf);

      }



      if (GetConfStr(cParm,nParm,"UPDATEMODE",buf)) {

         if (!strcmp (buf, "DUMP")) updateMode = UPMODE_DUMP;

         else if (!strcmp (buf, "UPDATE")) updateMode = UPMODE_UPDATE;

         else if (!strcmp (buf, "BOTH")) updateMode = UPMODE_BOTH;

         else HError(2319, "Unknown UPDATEMODE specified (must be DUMP, UPDATE or BOTH)");

      }

   }

}



void ReportUsage(void)

{

   printf("\nUSAGE: HERest [options] hmmList dataFiles...\n\n");

   printf(" Option                                       Default\n\n");

   printf(" -a      Use an input linear transform        off\n");

   printf(" -c f    Mixture pruning threshold            10.0\n");

   printf(" -d s    dir to find hmm definitions          current\n");

   printf(" -h s    set output speaker name pattern   *.%%%%%%\n");

   printf("         to s, optionally set input and parent patterns\n");

   printf(" -l N    set max files per speaker            off\n");

   printf(" -m N    set min examples needed per model    3\n");

   printf(" -o s    extension for new hmm files          as src\n");

   printf(" -p N    set parallel mode to N               off\n");

   printf(" -r      Enable Single Pass Training...       \n");

   printf("         ...using two parameterisations       off\n");

   printf(" -s s    print statistics to file s           off\n");

   printf(" -t f [i l] set pruning to f [inc limit]      inf\n");

   printf(" -u tmvwap  update t)rans m)eans v)ars w)ghts tmvw\n");

   printf("                a)daptation xform p)rior used     \n");

   printf("                s)semi-tied xform                 \n");

   printf(" -v f    set minimum variance to f            0.0\n");

   printf(" -w f    set mix weight floor to f*MINMIX     0.0\n");

   printf(" -x s    extension for hmm files              none\n");

   printf(" -z s    Save all xforms to TMF file s        TMF\n");

   PrintStdOpts("BEFGHIJKLMSTX");

   printf("\n\n");

}



void SetuFlags(void)

{

   char *s;

   

   s=GetStrArg();

   uFlags=(UPDSet) 0;        

   while (*s != '\0')

      switch (*s++) {

      case 't': uFlags = (UPDSet) (uFlags+UPTRANS); break;

      case 'm': uFlags = (UPDSet) (uFlags+UPMEANS); break;

      case 'v': uFlags = (UPDSet) (uFlags+UPVARS); break;

      case 'w': uFlags = (UPDSet) (uFlags+UPMIXES); break;

      case 's': uFlags = (UPDSet) (uFlags+UPSEMIT); break;

      case 'a': uFlags = (UPDSet) (uFlags+UPXFORM); break;

      case 'p': uFlags = (UPDSet) (uFlags+UPMAP); break;

      default: HError(2320,"SetuFlags: Unknown update flag %c",*s);

         break;

      }

}



/* ScriptWord: return next word from script */

char *ScriptWord(FILE *script, char *scriptBuf)

{

   int ch,qch,i;

   

   i=0; ch=' ';

   while (isspace(ch)) ch = fgetc(script);

   if (ch==EOF) {

      scriptBuf=NULL;

      return NULL;

   }

   if (ch=='\'' || ch=='"'){

      qch = ch;

      ch = fgetc(script);

      while (ch != qch && ch != EOF) {

         scriptBuf[i++] = ch; 

         ch = fgetc(script);

      }

      if (ch==EOF)

         HError(5051,"ScriptWord: Closing quote missing in script file");

   } else {

      do {

         scriptBuf[i++] = ch; 

         ch = fgetc(script);

      }while (!isspace(ch) && ch != EOF);

   }

   scriptBuf[i] = '\0';



   return scriptBuf;

}



void CheckUpdateSetUp()

{

  AdaptXForm *xf;
Beispiel #21
0
static std::vector<paint_session> extract_paint_session(const std::string parkFileName)
{
    core_init();
    gOpenRCT2Headless = true;
    auto context = OpenRCT2::CreateContext();
    std::vector<paint_session> sessions;
    log_info("Starting...");
    if (context->Initialise())
    {
        drawing_engine_init();
        if (!context->LoadParkFromFile(parkFileName))
        {
            log_error("Failed to load park!");
            return {};
        }

        gIntroState = INTRO_STATE_NONE;
        gScreenFlags = SCREEN_FLAGS_PLAYING;

        int32_t mapSize = gMapSize;
        int32_t resolutionWidth = (mapSize * 32 * 2);
        int32_t resolutionHeight = (mapSize * 32 * 1);

        resolutionWidth += 8;
        resolutionHeight += 128;

        rct_viewport viewport;
        viewport.x = 0;
        viewport.y = 0;
        viewport.width = resolutionWidth;
        viewport.height = resolutionHeight;
        viewport.view_width = viewport.width;
        viewport.view_height = viewport.height;
        viewport.var_11 = 0;
        viewport.flags = 0;

        int32_t customX = (gMapSize / 2) * 32 + 16;
        int32_t customY = (gMapSize / 2) * 32 + 16;

        int32_t x = 0, y = 0;
        int32_t z = tile_element_height(customX, customY) & 0xFFFF;
        x = customY - customX;
        y = ((customX + customY) / 2) - z;

        viewport.view_x = x - ((viewport.view_width) / 2);
        viewport.view_y = y - ((viewport.view_height) / 2);
        viewport.zoom = 0;
        gCurrentRotation = 0;

        // Ensure sprites appear regardless of rotation
        reset_all_sprite_quadrant_placements();

        rct_drawpixelinfo dpi;
        dpi.x = 0;
        dpi.y = 0;
        dpi.width = resolutionWidth;
        dpi.height = resolutionHeight;
        dpi.pitch = 0;
        dpi.bits = (uint8_t*)malloc(dpi.width * dpi.height);

        log_info("Obtaining sprite data...");
        viewport_render(&dpi, &viewport, 0, 0, viewport.width, viewport.height, &sessions);

        free(dpi.bits);
        drawing_engine_dispose();
    }
    log_info("Got %u paint sessions.", std::size(sessions));
    return sessions;
}
//---------------------------------------------------------
bool CGridding_Spline_CSA::On_Execute(void)
{
	//-----------------------------------------------------
	if( Initialise(m_Points, true) == false )
	{
		return( false );
	}

	//-----------------------------------------------------
	int			i, x, y;
	TSG_Point	p;

	csa			*pCSA	= csa_create();

	csa_setnpmin(pCSA, Parameters("NPMIN")	->asInt());
	csa_setnpmax(pCSA, Parameters("NPMAX")	->asInt());
	csa_setk	(pCSA, Parameters("K")		->asInt());
	csa_setnppc	(pCSA, Parameters("NPPC")	->asDouble());

	//-----------------------------------------------------
	point	*pSrc	= (point *)SG_Malloc(m_Points.Get_Count() * sizeof(point));

	for(i=0; i<m_Points.Get_Count() && Set_Progress(i, m_Points.Get_Count()); i++)
	{
		pSrc[i].x	= m_Points[i].x;
		pSrc[i].y	= m_Points[i].y;
		pSrc[i].z	= m_Points[i].z;
	}

	csa_addpoints(pCSA, m_Points.Get_Count(), pSrc);

	m_Points.Clear();

	//-----------------------------------------------------
	point	*pDst	= (point *)SG_Malloc(m_pGrid->Get_NCells() * sizeof(point));

	for(y=0, i=0, p.y=m_pGrid->Get_YMin(); y<m_pGrid->Get_NY() && Set_Progress(y, m_pGrid->Get_NY()); y++, p.y+=m_pGrid->Get_Cellsize())
	{
		for(x=0, p.x=m_pGrid->Get_XMin(); x<m_pGrid->Get_NX(); x++, p.x+=m_pGrid->Get_Cellsize(), i++)
		{
			pDst[i].x	= p.x;
			pDst[i].y	= p.y;
		}
	}

	//-----------------------------------------------------
	Process_Set_Text(_TL("calculating splines..."));
	csa_calculatespline		(pCSA);

	Process_Set_Text(_TL("approximating points..."));
	csa_approximate_points	(pCSA, m_pGrid->Get_NCells(), pDst);

	//-----------------------------------------------------
	for(y=0, i=0; y<m_pGrid->Get_NY() && Set_Progress(y, m_pGrid->Get_NY()); y++)
	{
		for(x=0; x<m_pGrid->Get_NX(); x++, i++)
		{
			if( isnan(pDst[i].z) )
			{
				m_pGrid->Set_NoData(x, y);
			}
			else
			{
				m_pGrid->Set_Value(x, y, pDst[i].z);
			}
		}
	}

	//-----------------------------------------------------
	csa_destroy(pCSA);

	SG_Free(pSrc);
	SG_Free(pDst);

	//-----------------------------------------------------
	return( true );
}
Beispiel #23
0
//load the desktop file or the required template
void Dialog::LoadDesktopFile(QString input)
{
  //if we have "-" as 1st char, it means that this is not a desktop file, but a parameter
  desktopFileName = input;
  if (input.startsWith("-")) {
    QMessageBox::critical(this,tr("Error"),tr("The filename cannot start with a \"-\"."));
    exit(1);
  }
  //if proposed file does not exist, than we will create one based on the templates
  QFileInfo info(desktopFileName);
  if ((info.size() == 0) && (desktopFileName.endsWith(".desktop"))) {
    QFile::remove(desktopFileName); //for the copy, we need to remove it
    if (desktopType=="link") {
      copyTemplate("-link");
    } else {
      copyTemplate("-app");
    }
  }
  this->setWindowTitle(desktopFileName.section("/",-1));
  ui->tabWidget->setCurrentIndex(0); //always start on the file info tab
  //Now load the file info and put it into the UI
  QString mime = LXDG::findAppMimeForFile(desktopFileName);
  
  QList<QByteArray> fmt = QImageReader::supportedImageFormats();
  bool foundimage=false;
    for(int i=0; i<fmt.length(); i++){ 
      if(info.suffix().toLower() == QString(fmt[i]).toLower()){foundimage=true; break; }
    }
  if(foundimage){
    ui->label_file_icon->setPixmap( QPixmap(desktopFileName).scaledToHeight(64) );
  }else{
    ui->label_file_icon->setPixmap( LXDG::findMimeIcon(mime).pixmap(QSize(64,64)) );	  
  }
  ui->label_file_mimetype->setText(mime);
  QString type;
  if(desktopFileName.endsWith(".desktop")){ type = tr("XDG Shortcut"); }
  else if(info.isDir()){ type = tr("Directory"); ui->label_file_icon->setPixmap( LXDG::findIcon("folder","").pixmap(QSize(64,64)) ); }
  else if(info.isExecutable()){ type = tr("Binary"); }
  else{ type = info.suffix().toUpper(); }
  if(info.isHidden()){ type = QString(tr("Hidden %1")).arg(type); }
  ui->label_file_type->setText(type);
  double bytes = info.size();
  QStringList lab; lab << "B" << "KB" << "MB" << "GB" << "TB" << "PB";
  int i=0;
  while(i<lab.length() && bytes>1024){
    bytes = bytes/1024;
    i++; //next label
  }
  //convert the size to two decimel places and add the label
  QString sz = QString::number( qRound(bytes*100)/100.0 )+lab[i];
  ui->label_file_size->setText( sz );
  ui->label_file_owner->setText(info.owner());
  ui->label_file_group->setText(info.group());
  QString perms;
  if(info.isReadable() && info.isWritable()){ perms = tr("Read/Write"); }
  else if(info.isReadable()){ perms = tr("Read Only"); }
  else if(info.isWritable()){ perms = tr("Write Only"); }
  else{ perms = tr("No Access"); }
  ui->label_file_perms->setText(perms);
  ui->label_file_created->setText( info.created().toString(Qt::SystemLocaleLongDate) );
  ui->label_file_modified->setText( info.lastModified().toString(Qt::SystemLocaleLongDate) );
  
  //use the standard LXDG object and load the desktop file
  bool ok = false;
  if(desktopFileName.endsWith(".desktop")){
    DF = LXDG::loadDesktopFile(desktopFileName, ok);
  }
  if( ok ) {
    if ((DF.type == XDGDesktop::LINK) && (desktopType!="link" )) {
      //we open a desktop type "link" but it was not mentionned by parameters
        Dialog::Initialise("-link");
    }
    ui->lName->setText(DF.name);
    ui->lComment->setText(DF.comment);
    ui->lCommand->setText(DF.exec);
    //in case of "link" desktop, we populate the correct content in lWorkingDir
    if (desktopType=="link") {
      ui->lWorkingDir->setText(DF.url);
    } else {
      ui->lWorkingDir->setText(DF.path);
    }
    if (DF.startupNotify) ui->cbStartupNotification->setChecked(true); else ui->cbStartupNotification->setChecked(false);
    if (DF.useTerminal) ui->cbRunInTerminal->setChecked(true); else ui->cbRunInTerminal->setChecked(false);
    iconFileName="";
    ui->pbIcon->setIcon(LXDG::findIcon(DF.icon,""));
    if(!info.isWritable()){ ui->tab_deskedit->setEnabled(false); }
  } else {
    ui->tabWidget->removeTab(1);
    return;
  }

  //we load the file in memory and will adapt it before saving it to disk
  QFile file(desktopFileName);
  inMemoryFile="";
  if (file.open(QFile::ReadOnly)) {
    QTextStream fileData(&file);
    inMemoryFile = fileData.readAll();
    file.close();
    //perform some validation checks
    //this will allow checks improvements without compilation of the file
    if ((inMemoryFile.contains(QRegExp(".*\\[Desktop Entry\\].*\n"))) &&
      (inMemoryFile.contains(QRegExp("\n\\s*Type\\s*=.*\n"))) &&
      (inMemoryFile.contains(QRegExp("\n\\s*Name\\s*=.*\n")))) {
      //qDebug() << "sounds a good file"; 
    } else {
      //qDebug() << "wrong file!!!!";
      QMessageBox msgBox;
      msgBox.setIcon(QMessageBox::Question);
      msgBox.setText(tr("There are some issues with this file !!!!"));
      msgBox.setInformativeText(tr("Either you correct this file your self with an editor, or you start from scratch using the link or app template.\nPlease note that this process will update the file called:") + desktopFileName);
      QPushButton *linkButton = msgBox.addButton("Link",QMessageBox::AcceptRole);
      QPushButton *appButton = msgBox.addButton("App",QMessageBox::ResetRole);
      QPushButton *cancelButton = msgBox.addButton("Cancel",QMessageBox::NoRole);
      msgBox.exec();
      if (msgBox.clickedButton() == linkButton) {
        QFile::remove(desktopFileName);
        copyTemplate("-link");
        Initialise("-link");
        LoadDesktopFile(desktopFileName);
      }
      if (msgBox.clickedButton() == appButton) {
        QFile::remove(desktopFileName);
        copyTemplate("-app");
        Initialise("-app");
        LoadDesktopFile(desktopFileName);
      }
      if (msgBox.clickedButton() == cancelButton) {
        //we stop here
        exit(0);
      }
    }
  }
}
Beispiel #24
0
Event::Event( Monitor *p_monitor, struct timeval p_start_time, const std::string &p_cause, const StringSetMap &p_noteSetMap ) :
    monitor( p_monitor ),
    start_time( p_start_time ),
    cause( p_cause ),
    noteSetMap( p_noteSetMap )
{
    if ( !initialised )
        Initialise();

    std::string notes;
    createNotes( notes );

    bool untimedEvent = false;
    if ( !start_time.tv_sec )
    {
        untimedEvent = true;
        gettimeofday( &start_time, 0 );
    }

    static char sql[ZM_SQL_MED_BUFSIZ];

    struct tm *stime = localtime( &start_time.tv_sec );
    snprintf( sql, sizeof(sql), "insert into Events ( MonitorId, Name, StartTime, Width, Height, Cause, Notes ) values ( %d, 'New Event', from_unixtime( %ld ), %d, %d, '%s', '%s' )", monitor->Id(), start_time.tv_sec, monitor->Width(), monitor->Height(), cause.c_str(), notes.c_str() );
    if ( mysql_query( &dbconn, sql ) )
    {
        Error( "Can't insert event: %s", mysql_error( &dbconn ) );
        exit( mysql_errno( &dbconn ) );
    }
    id = mysql_insert_id( &dbconn );
    if ( untimedEvent )
    {
        Warning( "Event %d has zero time, setting to current", id );
    }
    end_time.tv_sec = 0;
    frames = 0;
    alarm_frames = 0;
    tot_score = 0;
    max_score = 0;

    if ( config.use_deep_storage )
    {
        char *path_ptr = path;
        path_ptr += snprintf( path_ptr, sizeof(path), "%s/%d", config.dir_events, monitor->Id() );

        int dt_parts[6];
        dt_parts[0] = stime->tm_year-100;
        dt_parts[1] = stime->tm_mon+1;
        dt_parts[2] = stime->tm_mday;
        dt_parts[3] = stime->tm_hour;
        dt_parts[4] = stime->tm_min;
        dt_parts[5] = stime->tm_sec;

        char date_path[PATH_MAX] = "";
        char time_path[PATH_MAX] = "";
        char *time_path_ptr = time_path;
        for ( unsigned int i = 0; i < sizeof(dt_parts)/sizeof(*dt_parts); i++ )
        {
            path_ptr += snprintf( path_ptr, sizeof(path)-(path_ptr-path), "/%02d", dt_parts[i] );

            struct stat statbuf;
            errno = 0;
            stat( path, &statbuf );
            if ( errno == ENOENT || errno == ENOTDIR )
            {
                if ( mkdir( path, 0755 ) )
                {
                    Fatal( "Can't mkdir %s: %s", path, strerror(errno));
                }
            }
            if ( i == 2 )
                strncpy( date_path, path, sizeof(date_path) );
            else if ( i >= 3 )
                time_path_ptr += snprintf( time_path_ptr, sizeof(time_path)-(time_path_ptr-time_path), "%s%02d", i>3?"/":"", dt_parts[i] );
        }
        char id_file[PATH_MAX];
        // Create event id symlink
        snprintf( id_file, sizeof(id_file), "%s/.%d", date_path, id );
        if ( symlink( time_path, id_file ) < 0 )
            Fatal( "Can't symlink %s -> %s: %s", id_file, path, strerror(errno));
        // Create empty id tag file
        snprintf( id_file, sizeof(id_file), "%s/.%d", path, id );
        if ( FILE *id_fp = fopen( id_file, "w" ) )
            fclose( id_fp );
        else
            Fatal( "Can't fopen %s: %s", id_file, strerror(errno));
    }
    else
    {
        snprintf( path, sizeof(path), "%s/%d/%d", config.dir_events, monitor->Id(), id );
        
        struct stat statbuf;
        errno = 0;
        stat( path, &statbuf );
        if ( errno == ENOENT || errno == ENOTDIR )
        {
            if ( mkdir( path, 0755 ) )
            {
                Error( "Can't mkdir %s: %s", path, strerror(errno));
            }
        }
        char id_file[PATH_MAX];
        // Create empty id tag file
        snprintf( id_file, sizeof(id_file), "%s/.%d", path, id );
        if ( FILE *id_fp = fopen( id_file, "w" ) )
            fclose( id_fp );
        else
            Fatal( "Can't fopen %s: %s", id_file, strerror(errno));
    }
    last_db_frame = 0;
}
Beispiel #25
0
CMOOSDBHTTPServer::CMOOSDBHTTPServer(long lDBPort)
{
    Initialise(lDBPort, DEFAULT_WEBSERVER_PORT);
}
Beispiel #26
0
CSystemTray::CSystemTray(CWnd* pParent, UINT uCallbackMessage, LPCTSTR szToolTip, 
                         HICON icon, UINT uID)
{
    Initialise();
    Create(pParent, uCallbackMessage, szToolTip, icon, uID);
}
Beispiel #27
0
int main(int argc, char *argv[])
{
   int i;
   char *c,*s,*fn;
   char sBuf[256],fmt[256];

   void       Initialise(void);
   void       ProcessText(char *fn,bool lastFile);
   bool    Exists(char *fn);
   BackOffLM *CombineModels(MemHeap *heap,LMInfo *lmi,int nLModel,int nSize,WordMap *wl) ;

   InitShell(argc,argv,ladapt_version,ladapt_vc_id);
   InitMem();
   InitMath();
   InitWave();
   InitLabel();
   InitLUtil();
   InitWMap();
   InitGBase();
   InitLModel();
   InitPCalc();
   InitPMerge();

   SetConfParms();

   if (!InfoPrinted() && NumArgs() == 0)
      ReportUsage();
   if (NumArgs() == 0) Exit(EXIT_SUCCESS);

   InitBuildInfo(&binfo); 
   binfo.dctype = DC_ABSOLUTE;
   nLModel = 1;
   while (NextArg() == SWITCHARG) {
      s = GetSwtArg();
      if (strlen(s)!=1) 
         HError(16419,"Bad switch %s; must be single letter",s);
      switch(s[0]){
         case 'a':
            newWords = GetChkedInt(10,10000000,s); break;
         case 'b':
            ngbSize = GetChkedInt(10,10000000,s); break;
         case 'c':
            i = GetChkedInt(2,LM_NSIZE,s); 
	    binfo.cutOff[i] = GetChkedInt(0,1000,s);
	    break;
         case 'd':
            if (NextArg()!=STRINGARG)
               HError(16419,"Gram base root file name expected");
            rootFN = GetStrArg(); 
	    break;
         case 'f':
	    strcpy(fmt, GetStrArg());
	    for (c=fmt; *c; *c=toupper(*c), c++); /* To uppercase */
	    if (strcmp(fmt, LM_TXT_TEXT)==0)
	      binfo.saveFmt = LMF_TEXT;
	    else if (strcmp(fmt, LM_TXT_BINARY)==0)
	       binfo.saveFmt = LMF_BINARY;
	    else if (strcmp(fmt, LM_TXT_ULTRA)==0)
	       binfo.saveFmt = LMF_ULTRA;
	    else
	       HError(16419,"Unrecognised LM format, should be one of [%s, %s, %s]",
		      LM_TXT_TEXT, LM_TXT_BINARY, LM_TXT_ULTRA);
	    break;
         case 'g':
            processText = FALSE; break;
	 case 'i':
            if (NextArg()!=FLOATARG)
	       HError(16419,"Interpolation weight expected");
	    lmInfo[nLModel].weight = GetChkedFlt(0.0,1.0,s);
            if (NextArg()!=STRINGARG)
	       HError(16419,"Interpolation LM filename expected");
	    lmInfo[nLModel].fn = GetStrArg();
	    nLModel++;
	    break;
         case 'j':
            i = GetChkedInt(2,LM_NSIZE,s); 
	    binfo.wdThresh[i] = GetChkedFlt(0.0,1E10,s);
	    break;
         case 'n':
            nSize = GetChkedInt(1, MAXNG, s); break;
#ifdef HTK_TRANSCRIBER
         case 's':
            if (NextArg()!=STRINGARG)
               HError(16419,"Gram file text source descriptor expected");
            txtSrc = GetStrArg(); break;
         case 't':
	    binfo.dctype = DC_KATZ; break;
#endif
         case 'w':
            if (NextArg()!=STRINGARG)
               HError(16419,"Word list file name expected");
            wlistFN = GetStrArg(); break;
#ifndef HTK_TRANSCRIBER
         case 'x':
            binfo.ptype = LMP_COUNT; break;
#endif
         case 'T':
            trace = GetChkedInt(0,077,s); break;
         default:
            HError(16419,"LAdapt: Unknown switch %s",s);
      }
   }
#ifdef HTK_TRANSCRIBER
   if (nLModel==1) {  /* must interpolate with at least one model */
      HError(16419,"LAdapt: at least one model must be specified with -i option");
   }
   if (binfo.saveFmt==LMF_TEXT) { /* save fomat cannot be TEXT */ 
      binfo.saveFmt=LMF_BINARY;
   }
#endif
   if (NextArg() != STRINGARG)
      HError(16419,"LAdapt: language model file name expected");
   outFN = CopyString(&gstack,GetStrArg());

   Initialise();
   if (processText) {
      if (NextArg() != STRINGARG)
	 ProcessText(NULL,TRUE);       /* input from stdin */
      else
	 while (NextArg() == STRINGARG) {
	    /* !! copy string argument since it gets overwritten 
	       by NextArg() when reading from script file */
	    fn = CopyString(&gstack,GetStrArg());
	    ProcessText(fn,NextArg() != STRINGARG);
	 }
      if (NumArgs() != 0)
	 HError(-16419,"LAdapt: unused args left on cmd line");
      for (i=0; i<stdBuf.ngb->fndx; i++) {
	 sprintf(sBuf,"%s.%d",stdBuf.ngb->fn,i);  
	 AddInputGFile(&inSet,sBuf,1.0);
      }
      ResetHeap(&langHeap);
   } else {
      for (i=0; i<MAX_NGRAM_FILES; i++) {
	 sprintf(sBuf,"%s.%d",rootFN,i);
	 if (!Exists(sBuf))
	    break;
	 AddInputGFile(&inSet,sBuf,1.0);
      }
      if (i==MAX_NGRAM_FILES)
      {
	HError(-16419, "LAdapt: Only %d n-gram files read (recompile with different setting\nof MAX_NGRAM_FILES");
      }
   }
   if (nLModel==1) {
      adpLM = GenerateModel(&langHeap,&binfo);
   } else {
      if (binfo.ptype==LMP_COUNT) 
	 binfo.ptype = LMP_FLOAT;
      newLM = GenerateModel(&langHeap,&binfo);
      lmInfo[0].lm = newLM;
      lmInfo[0].fn = "unknown";
      /* combine all models into one */
      adpLM = CombineModels(&langHeap,lmInfo,nLModel,nSize,tgtVoc);
   }
#ifdef HTK_TRANSCRIBER
#ifdef HTK_CRYPT
   adpLM->encrypt = TRUE;     /* force to write encrypted model */
#endif
#endif
   SaveLangModel(outFN,adpLM);

   Exit(EXIT_SUCCESS);
   return EXIT_SUCCESS; /* never reached -- make compiler happy */
}
// Solution method
void NewtonSolver::Solve(arma::vec& solution,
    arma::vec& residualHistory,
    ExitFlagType& exitFlag,
    arma::mat* pJacobianExternal)
{

  // Parse parameter list
  Initialise();

  // Eventually print the header
  if (mPrintOutput)
  {
    PrintHeader("Newton Method", mMaxIterations, mTolerance);
  }

  // Check if dimensions are compatible
  int problem_size = mpInitialGuess->n_rows;
  assert( problem_size == solution.n_rows );

  // Iterator
  int iteration = 0;

  // Assign initial guess
  solution = *mpInitialGuess;

  // Initial residual
  arma::vec residual(problem_size);
  mpProblem->ComputeF(solution,residual);

  // Residual norm
  double residual_norm = arma::norm(residual,2);

  // Residual history
  residualHistory.set_size(1+mpParameterList->maxIterations);
  residualHistory(iteration) = residual_norm;

  // Eventually print iteration
  if (mPrintOutput)
  {
    PrintIteration(iteration, residual_norm, true);
  }

  // Check convergence
  bool converged = mpConvergenceCriterion->TestConvergence(residual_norm);

  arma::mat jacobian(problem_size,problem_size);
  // Newton's method main loop
  while ( (iteration < mMaxIterations) && (!converged) )
  {

    // Compute Jacobian (eventually use finite differences)
    if (mpProblemJacobian)
    {
      mpProblemJacobian->ComputeDFDU(solution,jacobian);
    }
    else
    {
      ComputeDFDU(solution,residual,jacobian);
    }

    // Linear solve to find direction
    arma::vec direction = arma::solve( jacobian, -residual);

    // Update solution
    solution += direction;

    // Update iterator
    iteration++;

    // Update residual
    mpProblem->ComputeF(solution,residual);

    // Update residual norm
    residual_norm = arma::norm(residual,2);

    // Check convergence
    converged = mpConvergenceCriterion->TestConvergence(residual_norm);

    // Update residual history
    residualHistory(iteration) = residual_norm;

    // Print infos
    if (mPrintOutput)
    {
      PrintIteration(iteration, residual_norm);
    }


  }

  // Trim residual history
  residualHistory.head(iteration);

  // Assign exit flag
  if (converged)
  {
    exitFlag = AbstractNonlinearSolver::ExitFlagType::converged;
  }
  else
  {
    exitFlag = AbstractNonlinearSolver::ExitFlagType::notConverged;
  }

  // Eventually print final message
  if (mPrintOutput)
  {
    PrintFooter(iteration, exitFlag);
  }

  // Output to external jacobian if requested
  if (pJacobianExternal)
  {
    assert( (*pJacobianExternal).n_rows==problem_size);
    assert( (*pJacobianExternal).n_cols==problem_size);
    assert( jacobian.n_rows==problem_size);
    (*pJacobianExternal) = jacobian;
  }

}
BoundedArray<T>::BoundedArray(BoundedArray &_otherArray)
{
    Initialise( _otherArray );
}
Beispiel #30
0
int main(int argc, char** argv)
{
  Opaque o = Initialise(argc);
  return 0;
}