ARCS/en

Un article de Wiki-evr@.

Version du 20 juillet 2006 à 13:39 (modifier) Gi (Discuter | Contributions) (→Component Initializations) ← Différence précédente		Version actuelle (17 novembre 2011 à 22:19) (modifier) (défaire) Gi (Discuter | Contributions)
(4 révisions intermédiaires masquées)
Ligne 4 :		Ligne 4 :
	The core of the framework is a general purpose component system cutomized to meet the requirements of augmented reality applications (mostly real-time constraints). A set of components is developped on top of this system for augmented reality applications.		The core of the framework is a general purpose component system cutomized to meet the requirements of augmented reality applications (mostly real-time constraints). A set of components is developped on top of this system for augmented reality applications.
-	== Motivations ==	+	[http://arcs.ibisc.univ-evry.fr ARCS has now its own website.]
		+
		+
		+	<!--== Motivations ==
	During the last years, AR (Augmented Reality) community		During the last years, AR (Augmented Reality) community
	has proven the need of an infrastructure. Almost		has proven the need of an infrastructure. Almost
Ligne 46 :		Ligne 49 :
	Our solution is based on the signal/slot communication		Our solution is based on the signal/slot communication
	model between components. This paradigm, mainly		model between components. This paradigm, mainly
-	used in user interfaces API, tends to reach other scopes	+	used in user interfaces API, reaches other scopes
-	of specific programming. Some libraries are implementing	+	of programming. Some libraries are implementing
	it, for example: QT [http://www.trolltech.com ],		it, for example: QT [http://www.trolltech.com ],
	libsigc++ [http://libsigc.sourceforge.net] derived from		libsigc++ [http://libsigc.sourceforge.net] derived from
Ligne 55 :		Ligne 58 :
	triggered when the signal is ”emitted”. Signals and		triggered when the signal is ”emitted”. Signals and
	slots can be connected and disconnected dynamically		slots can be connected and disconnected dynamically
-	at runtime and are managed. That is to say, connections	+	at runtime and are managed.
-	are tracked by objects owning signals and slots.	+
-	They’re able to automatically disconnect signal/slot	+
-	connections when one of the object involved in communication	+
-	is destroyed. This allows the user to make	+
-	signal/slot connections without expending a great effort	+
-	to manage the lifetimes of those connections with	+
-	regard to the lifetimes of all objects involved.	+
-	==== Component representation ====	+	==== Component representation ====-->
-	[[Image:ARCS_component.png|right|thumb|ARCS Component representation]]	+	<!--[[Image:ARCS_component.png|right|thumb|ARCS Component representation]]--><!--
	A component in ARCS is an entity		A component in ARCS is an entity
	or object able to export by itself its interface which is		or object able to export by itself its interface which is
Ligne 86 :		Ligne 82 :
	==== Component Initializations ====		==== Component Initializations ====
-	[[Image:ARCS_Preconnexion.png|thumb|250px|Pre-connexion initialization. Since components are not connected, initializations cannot propagate]]	+	--><!--[[Image:ARCS_Preconnexion.png|thumb|250px|Pre-connexion initialization. Since components are not connected, initializations cannot propagate]]-->
-	[[Image:ARCS_Postconnexion.png|thumb|250px|Post-connexion initialization. When components are connected, if a slot triggers a signal, then the initialization may propagate through components]]	+	<!--[[Image:ARCS_Postconnexion.png|thumb|250px|Post-connexion initialization. When components are connected, if a slot triggers a signal, then the initialization may propagate through components]]-->
-		+	<!--
	Components initializations are performed through		Components initializations are performed through
-	slots. However, these slots must meet a few requirements.	+	slots with only one parameter which to a list of simple types such as
-	They must have only one parameter and this	+
-	parameter belongs to a list of simple types such as	+
	strings, numerical values and other components.		strings, numerical values and other components.
-	Further, we will establish a distinction between two	+	We establish a distinction between two
	kinds of initializations depending on when they’re triggered.		kinds of initializations depending on when they’re triggered.
	Indeed, a slot call can also trigger a signal that		Indeed, a slot call can also trigger a signal that
Ligne 110 :		Ligne 104 :
	Since a component can be connected to other components,		Since a component can be connected to other components,
-	we will see the different solutions we have to	+	we will see how they communicate to each other.
-	connect components.	+
	=== Compositions of components ===		=== Compositions of components ===
-	==== The sheet, an explicit composition ====	+	An explicit composition let us know exactly how components are connected.
-	[[Image:ARCS_sheet.png|right|350px|thumb]]	+	It is performed by connecting signals to slots.
		+
		+	==== The sheet concept ====-->
		+	<!--[[Image:ARCS_sheet.png|right|350px|thumb]]-->
		+	<!--We introduce here the concept
		+	of sheet. In a component based framework, an application
		+	could be seen as a set of components working (or
		+	more properly communicating) together. We choose
		+	to name this set a “sheet”.
		+	A sheet is storing components initialization and
		+	components signal/slots connections.
		+
		+	==== Macro-blocks ====
		+	A sheet can also be used to represent a subset of components
		+	working together. They will be called macroblocks.
		+	They are defined by global slots and
		+	signals to which classical components of our system
		+	can connect and interact. These global inputs/outputs
		+	are mapped to internal components of the macroblock.
		+
		+	==== Extensions of composition mechanism ====
		+	We will introduce two more mechanisms, the first is
		+	consisting in using a state machine and the second is
		+	dedicated to components life-cycle management.
-	==== Initialisations of components ====	+	===== Adding a statemachine =====
		+	Indeed, a sheet reflects a state of an application.
		+	An application could be seen as a stack of sheets. We
		+	then need a mechanism to switch between sheets: its core is a statemachine.
-	==== Other composition mechanism ====	+	A state machine
		+	is, in our case, composed of states and transitions.
		+	The transitions are described by an initial state,
		+	a token and a final state.
		+	Sheets are modified to send tokens to the statemachine
		+	relying on one specific component for it.
		+	Each token sent to the state machine
		+	can make it switch to another application state
		+	that will be represented by another sheet.
		+	The new
		+	state can be a terminal state that will shutdown components.
		+	If we suppose a sheet (current sheet) is active and
		+	that the state machine has received an identified token
		+	triggering a transition, the sheet switch mechanism
		+	will follow these steps:
		+	# ''Disconnections:'' each signal/slot connection of the current sheet is destroyed. All components specifically instantiated for the current sheet are destroyed. All components communications are stopped,
		+	# ''Change of current sheet:'' the final state of the triggered transition becomes the current sheet. Each object that needs to be specifically set up for the sheet is instantiated,
		+	# ''Pre-connection initializations:'' before connecting signal/slot couples of the current sheet, components can be initialized separately,
		+	# ''Connections:'' each signal/slot connection described in the current sheet is activated. New communication links between components are established,
		+	# ''Post-connection initializations:'' reserved to initializations that propagate through different components when they’re connected to each other.
-	=== Extending the sheet capabilities ===	+	This described mechanism allows us to change the
		+	data path between components. We then have a reconfigurable
		+	data-flow. At the same time, life-cycle component management during the application run time is introduced
		+	in steps 1 and 2.-->
	== Publications ==		== Publications ==
	{{bibtex|Didier06}}		{{bibtex|Didier06}}

---

Version actuelle

ARCS (for Augmented Reality Component System) is a framework dedicated to the design of augmented reality applications. The core of the framework is a general purpose component system cutomized to meet the requirements of augmented reality applications (mostly real-time constraints). A set of components is developped on top of this system for augmented reality applications.

ARCS has now its own website.

[modifier] Publications

J.Y. Didier, S. Otmane, M. Mallem - A Component Model for Augmented/Mixed Reality Applications with Reconfigurable Data-flow

8th International Conference on Virtual Reality (VRIC 2006) pp. 243-252, Laval (France), April 26-28, 2006

Pdf Bibtex