ARCS/en - Historique des versions

Gi le 17 novembre 2011 à 22:19

Gi — Thu, 17 Nov 2011 22:19:15 GMT

← Version précédente		Version du 17 novembre 2011 à 22:19
Ligne 3 :		Ligne 3 :
	'''ARCS''' (for '''A'''ugmented '''R'''eality '''C'''omponent '''S'''ystem) is a framework dedicated to the design of augmented reality applications.		'''ARCS''' (for '''A'''ugmented '''R'''eality '''C'''omponent '''S'''ystem) 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.		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.
		+
		+	[http://arcs.ibisc.univ-evry.fr ARCS has now its own website.]
		+

	<!--== Motivations ==		<!--== Motivations ==

Gi le 23 octobre 2006 à 09:00

Gi — Mon, 23 Oct 2006 09:00:56 GMT

← Version précédente		Version du 23 octobre 2006 à 09:00
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 ==	+	<!--== 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 57 :		Ligne 57 :
	at runtime and are managed.		at runtime and are managed.

-	==== 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 79 :		Ligne 79 :

	==== 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 with only one parameter which to a list of simple types such as		slots with only one parameter which to a list of simple types such as
Ligne 107 :		Ligne 107 :
	It is performed by connecting signals to slots.		It is performed by connecting signals to slots.

-	==== The sheet concept ====	+	==== The sheet concept ====-->
	<!--[[Image:ARCS_sheet.png\|right\|350px\|thumb]]-->		<!--[[Image:ARCS_sheet.png\|right\|350px\|thumb]]-->
-	We introduce here the concept	+	<!--We introduce here the concept
	of sheet. In a component based framework, an application		of sheet. In a component based framework, an application
	could be seen as a set of components working (or		could be seen as a set of components working (or
Ligne 159 :		Ligne 159 :
	data path between components. We then have a reconfigurable		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		data-flow. At the same time, life-cycle component management during the application run time is introduced
-	in steps 1 and 2.	+	in steps 1 and 2.-->

	== Publications ==		== Publications ==
	{{bibtex\|Didier06}}		{{bibtex\|Didier06}}

Gi: /* The ARCS Core */

Gi — Mon, 24 Jul 2006 12:03:14 GMT

The ARCS Core

← Version précédente		Version du 24 juillet 2006 à 12:03
Ligne 58 :		Ligne 58 :

	==== 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 79 :		Ligne 79 :

	==== 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
Ligne 101 :		Ligne 101 :

	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.

-	==== ~~Initialisations of components~~ ====	+	==== 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.

-	==== ~~Other composition mechanism~~ ====	+	==== 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.

-	=== ~~Extending~~ the ~~sheet capabilities~~ ===	+	==== 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.
		+
		+	===== 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.
		+
		+	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.
		+
		+	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}}

Gi: /* Component Initializations */

Gi — Mon, 24 Jul 2006 11:41:48 GMT

Component Initializations

← Version précédente		Version du 24 juillet 2006 à 11:41
Ligne 83 :		Ligne 83 :

	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

Gi: /* Signal/slots */

Gi — Mon, 24 Jul 2006 11:27:44 GMT

Signal/slots

← Version précédente		Version du 24 juillet 2006 à 11:27
Ligne 46 :		Ligne 46 :
	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 55 :
	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 ====

Gi: /* Component Initializations */

Gi — Thu, 20 Jul 2006 13:39:07 GMT

Component Initializations

← Version précédente		Version du 20 juillet 2006 à 13:39
Ligne 86 :		Ligne 86 :

	==== Component Initializations ====		==== Component Initializations ====
		+	[[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]]
		+
	Components initializations are performed through		Components initializations are performed through
	slots. However, these slots must meet a few requirements.		slots. However, these slots must meet a few requirements.
Ligne 97 :		Ligne 100 :
	belongs to the same component; this last one may call		belongs to the same component; this last one may call
	another slot if a signal/slot connection is established		another slot if a signal/slot connection is established
-	between them. So, we have Pre-connection initializations	+	between them. So, we have ''Pre-connection initializations''
	that are performed before the component is		that are performed before the component is
	connected with others and we have a second category		connected with others and we have a second category
-	we call post-connection initialization that are triggered	+	we call ''post-connection initialization'' that are triggered
	after the component is connected to other ones. This		after the component is connected to other ones. This
	second one allows propagating initializations through		second one allows propagating initializations through
	connections.		connections.
		+

	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 the different solutions we have to
	connect components.		connect components.
-
-

	=== Compositions of components ===		=== Compositions of components ===

Gi: /* The ARCS Core */

Gi — Thu, 20 Jul 2006 13:25:19 GMT

The ARCS Core

← Version précédente		Version du 20 juillet 2006 à 13:25
Ligne 43 :		Ligne 43 :
	applications.		applications.

-	~~Before detailing our components, we should introduce the main communication mechanism~~	+	==== Signal/slots ====
-	~~we use, which is based on the signal/slot paradigm.~~	+
-		+
-	=== ~~Compositions of components~~ ===	+
-	~~=== Underlying concept : the~~ Signal/slots ~~paradigm~~ ===	+
	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
Ligne 68 :		Ligne 64 :
	regard to the lifetimes of all objects involved.		regard to the lifetimes of all objects involved.

		+	==== Component representation ====
		+	[[Image:ARCS_component.png\|right\|thumb\|ARCS Component representation]]
		+	A component in ARCS is an entity
		+	or object able to export by itself its interface which is
		+	made of signals and slots. As we will see,
		+	we will often use both the terms of components
		+	and objects to refer to the same thing, since the components
		+	we will develop are objects.
		+
		+	==== Component libraries ====
		+	Components are compiled pieces of code stored in dynamic
		+	libraries with three specific entry points:
		+	* one for describing objects stored in the library,
		+	* one for instantiating an object contained in the library,
		+	* one for destroying an object instantiated from this library.
		+
		+	Once components are stored in dynamic libraries, we
		+	can load and use them on demand. Therefore, a component
		+	may require some configuration so we need a
		+	system to set component properties.
		+
		+	==== Component Initializations ====
		+	Components initializations are performed through
		+	slots. However, these slots must meet a few requirements.
		+	They must have only one parameter and this
		+	parameter belongs to a list of simple types such as
		+	strings, numerical values and other components.
		+
		+	Further, we will establish a distinction between two
		+	kinds of initializations depending on when they’re triggered.
		+	Indeed, a slot call can also trigger a signal that
		+	belongs to the same component; this last one may call
		+	another slot if a signal/slot connection is established
		+	between them. So, we have Pre-connection initializations
		+	that are performed before the component is
		+	connected with others and we have a second category
		+	we call post-connection initialization that are triggered
		+	after the component is connected to other ones. This
		+	second one allows propagating initializations through
		+	connections.
		+
		+	Since a component can be connected to other components,
		+	we will see the different solutions we have to
		+	connect components.
		+
		+
		+
		+	=== Compositions of components ===
	==== The sheet, an explicit composition ====		==== The sheet, an explicit composition ====
		+	[[Image:ARCS_sheet.png\|right\|350px\|thumb]]

	==== Initialisations of components ====		==== Initialisations of components ====
Ligne 75 :		Ligne 120 :

	=== Extending the sheet capabilities ===		=== Extending the sheet capabilities ===
-

	== Publications ==		== Publications ==
	{{bibtex\|Didier06}}		{{bibtex\|Didier06}}

Gi le 20 juillet 2006 à 13:07

Gi — Thu, 20 Jul 2006 13:07:51 GMT

← Version précédente		Version du 20 juillet 2006 à 13:07
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.

-	== ~~Basics~~ ==	+	== Motivations ==
		+	During the last years, AR (Augmented Reality) community
		+	has proven the need of an infrastructure. Almost
		+	30 different projects of framework have been developed
		+	for AR {{refa\|Endres05}}.
		+
		+	Amongst these projects, the most remarkable ones are :
		+	* [http://studierstube.icg.tu-graz.ac.at Studierstube], one of the oldest project relying on a ditributed scenegraph,
		+	* [http://www.tinmith.net Tinmith], which is oriented for developpers,
		+	* [http://ar.in.tum.de/Chair/ProjectDwarf Dwarf], developped for distributed augmented reality services,
		+	* [http://www.amire.net AMIRE], which is the closest architecture to ARCS.
		+
		+	Our choice
		+	is to develop or rely on a component system
		+	that meets several requirements such as portability, a
		+	variable granularity, some scalability, and a high level
		+	of abstraction for end-users. As we will see, we will
		+	introduce component life-cycle management mechanisms
		+	in ours application developed with our framework.
		+	We will also combined it with with a system
		+	allowing on-line reconfiguration of data-flow.
		+
		+
		+
		+
		+	== The ARCS Core ==
	=== Components ===		=== Components ===
	According to Szyperski’s definition {{refa\|Szyperski02}}, “A component		According to Szyperski’s definition {{refa\|Szyperski02}}, “A component
Ligne 21 :		Ligne 46 :
	we use, which is based on the signal/slot paradigm.		we use, which is based on the signal/slot paradigm.

-	=== Signal/slots ===	+	=== Compositions of components ===
		+	=== Underlying concept : the Signal/slots paradigm ===
	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
Ligne 42 :		Ligne 68 :
	regard to the lifetimes of all objects involved.		regard to the lifetimes of all objects involved.

-	=== Why programming with components ? ===
-	During the last years, AR (Augmented Reality) community
-	has proven the need of an infrastructure. Almost
-	30 different projects of framework have been developed
-	for AR {{refa\|Endres05}}.
-
-	Amongst these projects, the most remarkable ones are :
-	* [http://studierstube.icg.tu-graz.ac.at Studierstube], one of the oldest project relying on a ditributed scenegraph,
-	* [http://www.tinmith.net Tinmith], which is oriented for developpers,
-	* [http://ar.in.tum.de/Chair/ProjectDwarf Dwarf], developped for distributed augmented reality services,
-	* [http://www.amire.net AMIRE], which is the closest architecture to ARCS.
-
-	Our choice
-	is to develop or rely on a component system
-	that meets several requirements such as portability, a
-	variable granularity, some scalability, and a high level
-	of abstraction for end-users. As we will see, we will
-	introduce component life-cycle management mechanisms
-	in ours application developed with our framework.
-	We will also combined it with with a system
-	allowing on-line reconfiguration of data-flow.
-
-	== The ARCS Core ==
-
-	=== Components ===
-
-	=== Compositions of components ===
	==== The sheet, an explicit composition ====		==== The sheet, an explicit composition ====

Gi: /* Why programming with components ? */

Gi — Thu, 20 Jul 2006 10:53:35 GMT

Why programming with components ?

← Version précédente		Version du 20 juillet 2006 à 10:53
Ligne 43 :		Ligne 43 :

	=== Why programming with components ? ===		=== Why programming with components ? ===
		+	During the last years, AR (Augmented Reality) community
		+	has proven the need of an infrastructure. Almost
		+	30 different projects of framework have been developed
		+	for AR {{refa\|Endres05}}.
		+
		+	Amongst these projects, the most remarkable ones are :
		+	* [http://studierstube.icg.tu-graz.ac.at Studierstube], one of the oldest project relying on a ditributed scenegraph,
		+	* [http://www.tinmith.net Tinmith], which is oriented for developpers,
		+	* [http://ar.in.tum.de/Chair/ProjectDwarf Dwarf], developped for distributed augmented reality services,
		+	* [http://www.amire.net AMIRE], which is the closest architecture to ARCS.
		+
		+	Our choice
		+	is to develop or rely on a component system
		+	that meets several requirements such as portability, a
		+	variable granularity, some scalability, and a high level
		+	of abstraction for end-users. As we will see, we will
		+	introduce component life-cycle management mechanisms
		+	in ours application developed with our framework.
		+	We will also combined it with with a system
		+	allowing on-line reconfiguration of data-flow.

	== The ARCS Core ==		== The ARCS Core ==

Gi: /* Signal/slots */

Gi — Thu, 20 Jul 2006 10:37:53 GMT

Signal/slots

← Version précédente		Version du 20 juillet 2006 à 10:37
Ligne 22 :		Ligne 22 :

	=== Signal/slots ===		=== Signal/slots ===
		+	Our solution is based on the signal/slot communication
		+	model between components. This paradigm, mainly
		+	used in user interfaces API, tends to reach other scopes
		+	of specific programming. Some libraries are implementing
		+	it, for example: QT [http://www.trolltech.com ],
		+	libsigc++ [http://libsigc.sourceforge.net] derived from
		+	GTK+, sigslot [http://sigslot.sourceforge.net] and boost [http://www.boost.org]. Signals represent callbacks
		+	with multiple targets. Signals are connected to some
		+	set of slots, which are callback receivers. They are
		+	triggered when the signal is ”emitted”. Signals and
		+	slots can be connected and disconnected dynamically
		+	at runtime and are managed. That is to say, connections
		+	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.

	=== Why programming with components ? ===		=== Why programming with components ? ===