In this paper, we shall consider the problem of deploying attention to the subsets of the video streams for collating the most relevant data and information of interest related to a given task. We formalize this monitoring problem as a foraging problem. We propose a probabilistic framework to model observer's attentive behavior as the behavior of a forager. The forager, moment to moment, focuses its attention on the most informative stream/camera, detects interesting objects or activities, or switches to a more profitable stream. The approach proposed here is suitable to be exploited for multistream video summarization. Meanwhile, it can serve as a preliminary step for more sophisticated video surveillance, e.g., activity and behavior analysis. Experimental results achieved on the UCR Videoweb Activities Data Set, a publicly available data set, are presented to illustrate the utility of the proposed technique.

The paper presents a layered architecture that improves software modularity and reduces computational and communication overhead for systems requiring data from sensors in order to perform domain-related elaborations (e.g., tracking and surveillance systems). Each layer manages hypotheses that are abductions related to objects modeling the ”real world” at a specific abstraction level, from raw data up to domain concepts. Each layer, by analyzing hypotheses coming from the lower layer, abduces new hypotheses regarding objects at a higher level of abstraction (e.g., from image blobs to identified people) and formulates timed previsions about objects. The failure of a prevision causes a hypothesis to flow up-stream. In turn, previsions can flow downstream, so that their verification is delegated to the lower layers. The proposed architectural patterns have been reified in a Java framework, which is being exploited in an experimental multi-camera tracking system.

The paper presents a set of architectural abstractions that allow time-related aspects to be explicitly treated as first-class programming concepts at the application level. Both the temporal behavior of an application and the way it deals with information placed in a temporal context can be modeled by means of such abstractions, thus narrowing the semantic gap between specification and implementation. The paper introduces the abstractions by means of a simplified reference problem and presents the validation of a concrete implementation.

The paper presents an integration platform for space-based interoperability among heterogeneous components in open smart spaces. The key idea is to rely on multiple spaces, be they physical or logical, and on mappings among spaces. Components publish their information on one or more spatial publication contexts, whereas they make subscriptions to one or more spatial subscription contexts. Information is delivered whenever a non-empty intersection among publication and subscription contexts is recognized according to the space mappings. The platform defines basic space models that can be specialized to model domain-specific spaces. The paper presents the basic platform mechanisms and their application in a sample scenario, discusses the benefits of the approach and compares it to significant related works.

The paper presents a platform aimed at supporting space-aware communications in emergency situations. The key idea is to rely on multiple spaces, be they physical or logical, and on mappings among spaces. Thematic information is published in one or more spatial publication contexts, whereas subscribers specify one or more spatial subscription contexts. Information is delivered whenever a non-empty intersection among publication and subscription contexts is recognized according to the space mappings. The platform defines basic space models that can be specialized to model domain-specific spaces. The paper overviews the basic platform mechanisms, sketches their exploitation in a concrete scenario and briefly discusses related works.

The paper presents a uniform approach to computing and communication, which seems well-suited to dynamically handle information flows in an emergency management system and overcomes the drawbacks of layered architectures. The overall system is modelled as a computational graph consisting of components and connectors, which are recursively modelled as lower-level graphs. Micro-components, i.e., software modules which can be executed on a single computational node, are the basic building blocks. This paves the way to the design and implementation of adaptive systems where both introspective and domain information are treated in a uniform way to realize context-aware strategies supporting distributed computations and context-aware routing.

We introduce software architecture for embedded, real-time monitoring systems. The architecture is based both upon sound software engineering principles and industrial experience in the application domain.

The paper presents a layered architecture for real-time surveillance systems. Each layer includes objects that model the "real world" at a specific abstraction level, from raw data up to domain concepts. Each layer performs abstractions on perceptions coming from the lower layer and formulates timed hypotheses about domain objects. The failure of a hypothesis causes a perception to flow up-stream. In turn, hypotheses flow down-stream, so that their verification is delegated to the lower layers. The proposed architectural patterns have been reified in a Java framework, which has been used in an experimental multi-camera tracking system.

Current design approaches to time-sensitive systems do not provide a coherent architectural framework for "non-functional" time-related requirements. The paper proposes Temporal Reflection as the ability of a system to self-represent, observe and adapt its own temporal behaviour through suitable architectural abstractions. The paper provides the rationale for Temporal Reflection and introduces the related abstractions by exemplifying the design and the implementation of a video player.

The design of object-oriented real-time distributed systems is especially hard due to the fact that some issues (concerned with distribution) are dealt with too early in the system life-cycle, while others (concerned with strategy) are hard-coded as programming-in-the-small issues, and still others (concerned with time) are hidden inside the operating system kernel. We present a reference architecture for monitoring and control systems that addresses the first two of these issues. The architecture raises distribution, activation and timing to an explicit, programming-in-the-large level.

As software systems become larger and more complex, a relevant part of code shifts from the application domain to the management of the system's run-time architecture (e.g., substituting components and connectors for run-time automated tuning). We propose a novel design approach for component based systems supporting architectural management in a systematic and conceptually clean way and allowing for the transparent addition of architectural management functionality to existing systems. The approach builds on the concept of reflection, extending it to the programming-in-the-large level, thus yielding architectural reflection (AR). The paper focuses on one aspect of AR, namely the monitoring and dynamic modification of the system's overall control structure (strategic reflection), which allows the behaviour of a system to be monitored and adjusted without modifying the system itself.

Realizing a shift of software engineering towards a component based approach to software development requires the development of higher level programming systems supporting the development of systems from components. The paper presents a novel approach to the design of large software systems where a program in the large describing the system's architecture is executed at run time to rule over the assembly and dynamic cooperation of components. This approach has several advantages following from a clean separation of concerns between programming in the small and programming in the large issues in instantiated systems.

As software systems become modular and distributed, the system architecture becomes a central design concern. Traditional environments provide poor support for crucial aspects such as configuration, interfacing to communication systems, global synchronization and scheduling. The paper identifies the basic abstractions for a complete description of a software system, possibly distributed and real-time. The proposed architectural model addresses software architecture issues to provide software engineers an integrated and coherent environment, and an architectural language to describe system components and their features. The environment is expected to support the complete life-cycle of software systems of different nature. It is accomplished by addressing each concern-design of single components, design of the system topology, set up and control system execution-as a separate issue, and by moving at design and programming level features traditionally belonging to operating systems and run-time supports of programming languages.

The paper presents an integrated approach to architectural design and to engineering of complex IT systems. It addresses the need for suitable architectural abstractions by introducing agents, connectors, configurators and controllers as abstract components exporting multi-view interfaces. Each view is visible to components implementing a specific abstraction. The paper also discusses how such abstract components can be implemented and engineered on different platforms by splitting them into concrete representations corresponding to specific views. The systematic use of these concepts leads to the definition of an integrated environment supporting the whole system life cycle.

The aim of a cooperative system is to coordinate and support group activities. CSDL (Cooperative Systems Design Language) is an experimental language designed to support the development of cooperative systems from specification to implementation. In CSDL a system is defined as a collection of reusable entities implementing floor control disciplines and shared workspaces. A cooperative system may be distributed over a variety of workstations and networks. Therefore, a design language should provide sound supports for system architecture definition and dynamic configuration. This paper surveys the language and discusses constructs for identifying starting and connecting system entities.>

The aim of a cooperative system is to coordinate and support group activities. Cooperative Systems Design Language (CSDL) is an experimental language designed to support the development of cooperative systems from specification to implementation. In CSDL, a system is defined as a collection of reusable entities implementing floor control disciplines and shared workspaces. CSDL tries to address the difficulties of integrating different aspects of cooperative systems: cooperation control, communication, and system modularization. This paper presents CSDL as a specification language. Basic units are coordinators that can be combined hierarchically. A coordinator is composed of a specification, a body, and a context. The specification defines the cooperation policy; the body controls the underlying communication channels; and the context defines coordinators' interaction in modular systems.>

Cooperative system programming deals with four topics: multiuser interfaces, coordination, shared workspace, and networking control. The goal of CSDL (Cooperative Systems Design Language) is to cover all these aspects. The authors present the development of a system in CSDL. The system allows a group of physically distributed users to edit a document concurrently. It permits sharing the single-user editor xedit by multiplexing the application's outputs to each participant, while inputs come from one user at a time. A simple floor control policy allows participants to designate who has that right. A detailed presentation of the coordination layer, and a discussion of system architecture are included.>

Article Free Access Share on ObNet: an object-oriented approach for supporting large, long-lived, highly configurable systems Authors: T. Gallo CRAI Consorzio per la Ricerca, e le Applicazioni di Informatica, 87036 Rende (CS), Italy CRAI Consorzio per la Ricerca, e le Applicazioni di Informatica, 87036 Rende (CS), ItalyView Profile , G. Serrano CRAI Consorzio per la Ricerca, e le Applicazioni di Informatica, 87036 Rende (CS), Italy CRAI Consorzio per la Ricerca, e le Applicazioni di Informatica, 87036 Rende (CS), ItalyView Profile , F. Tisato Dipartimento Elettrico, Universitità della Calabria, 87036 Rende (CS), Italy Dipartimento Elettrico, Universitità della Calabria, 87036 Rende (CS), ItalyView Profile Authors Info & Claims ICSE '89: Proceedings of the 11th international conference on Software engineeringMay 1989 Pages 138–144https://doi.org/10.1145/74587.74608Online:15 May 1989Publication History 3citation218DownloadsMetricsTotal Citations3Total Downloads218Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF