Showing papers on "Object-oriented design published in 2012"

3-D Object Retrieval and Recognition With Hypergraph Analysis

Abstract: View-based 3-D object retrieval and recognition has become popular in practice, e.g., in computer aided design. It is difficult to precisely estimate the distance between two objects represented by multiple views. Thus, current view-based 3-D object retrieval and recognition methods may not perform well. In this paper, we propose a hypergraph analysis approach to address this problem by avoiding the estimation of the distance between objects. In particular, we construct multiple hypergraphs for a set of 3-D objects based on their 2-D views. In these hypergraphs, each vertex is an object, and each edge is a cluster of views. Therefore, an edge connects multiple vertices. We define the weight of each edge based on the similarities between any two views within the cluster. Retrieval and recognition are performed based on the hypergraphs. Therefore, our method can explore the higher order relationship among objects and does not use the distance between objects. We conduct experiments on the National Taiwan University 3-D model dataset and the ETH 3-D object collection. Experimental results demonstrate the effectiveness of the proposed method by comparing with the state-of-the-art methods.

Methods and apparatus for dealing with malware

Abstract: In one aspect, a method of classifying a computer object as malware includes receiving at a base computer data about a computer object from each of plural remote computers on which the object or similar objects are stored. The data about the computer object received from the plural computers is compared in the base computer. The computer object is classified as malware on the basis of said comparison. In one embodiment, the data about the computer object includes one or more of : executable instructions contained within or constituted by the object; the size of the object; the name of the object; the logical storage location or path of the object on the respective remote computers; the vendor of the object; the software product and version associated with the object; and, events initiated by or involving the object when the object is created, configured or runs on the respective remote computers.

Displaying a collision between real and virtual objects

Abstract: Technology is described for displaying a collision between objects by an augmented reality display device system. A collision between a real object and a virtual object is identified based on three dimensional space position data of the objects. At least one effect on at least one physical property of the real object is determined based on physical properties of the real object, like a change in surface shape, and physical interaction characteristics of the collision. Simulation image data is generated and displayed simulating the effect on the real object by the augmented reality display. Virtual objects under control of different executing applications can also interact with one another in collisions.

Estimating the aspect layout of object categories

Abstract: In this work we seek to move away from the traditional paradigm for 2D object recognition whereby objects are identified in the image as 2D bounding boxes. We focus instead on: i) detecting objects; ii) identifying their 3D poses; iii) characterizing the geometrical and topological properties of the objects in terms of their aspect configurations in 3D. We call such characterization an object's aspect layout (see Fig. 1). We propose a new model for solving these problems in a joint fashion from a single image for object categories. Our model is constructed upon a novel framework based on conditional random fields with maximal margin parameter estimation. Extensive experiments are conducted to evaluate our model's performance in determining object pose and layout from images. We achieve superior viewpoint accuracy results on three public datasets and show extensive quantitative analysis to demonstrate the ability of accurately recovering the aspect layout of objects.

OOFEM — an Object-oriented Simulation Tool for Advanced Modeling of Materials and Structures

Abstract: The aim of this paper is to describe the object-oriented design of the finite element based simulation code. The overall, object-oriented structure is described, and the role of the fundamental classes is discussed. The paper discusses the advanced parallel, adaptive, and multiphysics capabilities of the OOFEM code, and illustrates them on the basis of selected examples.

Graph-Based Software Design for Managing Complexity and Enabling Concurrency in Multiphysics PDE Software

Abstract: Multiphysics simulation software is plagued by complexity stemming from nonlinearly coupled systems of Partial Differential Equations (PDEs). Such software typically supports many models, which may require different transport equations, constitutive laws, and equations of state. Strong coupling and a multiplicity of models leads to complex algorithms (i.e., the properly ordered sequence of steps to assemble a discretized set of coupled PDEs) and rigid software.This work presents a design strategy that shifts focus away from high-level algorithmic concerns to low-level data dependencies. Mathematical expressions are represented as software objects that directly expose data dependencies. The entire system of expressions forms a directed acyclic graph and the high-level assembly algorithm is generated automatically through standard graph algorithms. This approach makes problems with complex dependencies entirely tractable, and removes virtually all logic from the algorithm itself. Changes are highly localized, allowing developers to implement models without detailed understanding of any algorithms (i.e., the overall assembly process). Furthermore, this approach complements existing MPI-based frameworks and can be implemented within them easily.Finally, this approach enables algorithmic parallelization via threads. By exposing dependencies in the algorithm explicitly, thread-based parallelism is implemented through algorithm decomposition, providing a basis for exploiting parallelism independent from domain decomposition approaches.

Workflow-centric research objects: First class citizens in scholarly discourse.

Abstract: A workflow-centric research object bundles a workflow, the provenance of the results obtained by its enactment, other digital objects that are relevant for the experiment (papers, datasets, etc.), and annotations that semantically describe all these objects. In this paper, we propose a model to specify workflow-centric research objects, and show how the model can be grounded using semantic technologies and existing vocabularies, in particular the Object Reuse and Exchange (ORE) model and the Annotation Ontology (AO).We describe the life-cycle of a research object, which resembles the life-cycle of a scientific experiment.

Automatic discovery of groups of objects for scene understanding

Abstract: Objects in scenes interact with each other in complex ways. A key observation is that these interactions manifest themselves as predictable visual patterns in the image. Discovering and detecting these structured patterns is an important step towards deeper scene understanding. It goes beyond using either individual objects or the scene as a whole as the semantic unit. In this work, we promote "groups of objects". They are high-order composites of objects that demonstrate consistent spatial, scale, and viewpoint interactions with each other. These groups of objects are likely to correspond to a specific layout of the scene. They can thus provide cues for the scene category and can also prime the likely locations of other objects in the scene. It is not feasible to manually generate a list of all possible groupings of objects we find in our visual world. Hence, we propose an algorithm that automatically discovers groups of arbitrary numbers of participating objects from a collection of images labeled with object categories. Our approach builds a 4-dimensional transform space of location, scale and viewpoint, and efficiently identifies all recurring compositions of objects across images. We then model the discovered groups of objects using the deformable parts-based model. Our experiments on a variety of datasets show that using groups of objects can significantly boost the performance of object detection and scene categorization.

Object focus in a mixed reality environment

Abstract: A system and method are disclosed for interpreting user focus on virtual objects in a mixed reality environment. Using inference, express gestures and heuristic rules, the present system determines which of the virtual objects the user is likely focused on and interacting with. At that point, the present system may emphasize the selected virtual object over other virtual objects, and interact with the selected virtual object in a variety of ways.

In-scene real-time design of living spaces

Abstract: A display that renders realistic objects allows a designer to redesign a living space in real time based on an existing layout. A computer system renders simulated objects on the display such that the simulated objects appear to the viewer to be in substantially the same place as actual objects in the scene. The displayed simulated objects can be spatially manipulated on the display through various user gestures. A designer can visually simulate a redesign of the space in many ways, for example, by adding selected objects, or by removing or rearranging existing objects, or by changing properties of those objects. Such objects also can be associated with shopping resources to enable related goods and services to be purchased, or other commercial transactions to be engaged in.

Object co-detection

Abstract: In this paper we introduce a new problem which we call object co-detection. Given a set of images with objects observed from two or multiple images, the goal of co-detection is to detect the objects, establish the identity of individual object instance, as well as estimate the viewpoint transformation of corresponding object instances. In designing a co-detector, we follow the intuition that an object has consistent appearance when observed from the same or different viewpoints. By modeling an object using state-of-the-art part-based representations such as [1,2], we measure appearance consistency between objects by comparing part appearance and geometry across images. This allows to effectively account for object self-occlusions and viewpoint transformations. Extensive experimental evaluation indicates that our co-detector obtains more accurate detection results than if objects were to be detected from each image individually. Moreover, we demonstrate the relevance of our co-detection scheme to other recognition problems such as single instance object recognition, wide-baseline matching, and image query.

The Role of Design Spaces

Abstract: A central task in design is deciding what artifact will best satisfy the client's needs, whether that requires creating an artifact or choosing from existing alternatives. A design space identifies and organizes the decisions that must be made, together with the alternatives for those decisions, thereby providing guidance for creating artifacts or a framework for comparing them. The Studying Professional Software Design workshop studied three pairs of professional software designers sketching designs for a traffic signal simulator. A discussion of the design space for the simulation task shows how this design space enables comparison of the designs. It also illustrates the benefits of explicitly considering the design space during design and the risks of failing to do so.

Object-Oriented Techniques for Sparse Matrix Computations in Fortran 2003

Abstract: The efficiency of a sparse linear algebra operation heavily relies on the ability of the sparse matrix storage format to exploit the computing power of the underlying hardware. Since no format is universally better than the others across all possible kinds of operations and computers, sparse linear algebra software packages should provide facilities to easily implement and integrate new storage formats within a sparse linear algebra application without the need to modify it; it should also allow to dynamically change a storage format at run-time depending on the specific operations to be performed. Aiming at these important features, we present an Object Oriented design model for a sparse linear algebra package which relies on Design Patterns. We show that an implementation of our model can be efficiently achieved through some of the unique features of the Fortran 2003 language. Experimental results show that the proposed software infrastructure improves the modularity and ease of use of the code at no performance loss.

Patterns as objects in grace

Abstract: Object orientation and pattern matching are often seen as conflicting approaches to program design. Object-oriented programs place type-dependent behavior inside objects and invoke it via dynamic dispatch, while pattern-matching programs place type-dependent behavior outside data structures and invoke it via multiway conditionals (case statements). Grace is a new, dynamic, object-oriented language designed to support teaching: to this end, Grace needs to support both styles. We explain how this conflict can be resolved gracefully: by modelling patterns and cases as partial functions, reifying those functions as objects, and then building up complex patterns from simpler ones using pattern combinators. We describe the implementation of this design as an object-oriented framework, and a case study of its effectiveness.

Defect proneness estimation and feedback approach for software design quality improvement

Abstract: Context: Modern software engineering demands professionals and researchers to proactively and collectively work towards exploring and experimenting viable and valuable mechanisms in order to extract all kinds of degenerative bugs, security holes, and possible deviations at the initial stage. Having understood the real need here, we have introduced a novel methodology for the estimation of defect proneness of class structures in object oriented (OO) software systems at design stage. Objective: The objective of this work is to develop an estimation model that provides significant assessment of defect proneness of object oriented software packages at design phase of SDLC. This frame work enhances the efficiency of SDLC through design quality improvement. Method: This involves a data driven methodology which is based on the empirical study of the relationship existing between design parameters and defect proneness. In the first phase, a mapping of the relationship between the design metrics and normal occurrence pattern of defects are carried out. This is represented as a set of non linear multifunctional regression equations which reflects the influence of individual design metrics on defect proneness. The defect proneness estimation model is then generated by weighted linear combination of these multifunctional regression equations. The weighted coefficients are evaluated through GQM (Goal Question Metric) paradigm. Results: The model evaluation and validation is carried out with a selected set of cases which is found to be promising. The current study is successfully dealt with three projects and it opens up the opportunity to extend this to a wide range of projects across industries. Conclusion: The defect proneness estimation at design stage facilitates an effective feedback to the design architect and enabling him to identify and reduce the number of defects in the modules appropriately. This results in a considerable improvement in software design leading to cost effective products.

Application programming interface for efficient object information gathering and listing

Abstract: An information system has a database having distinct object structures that store information about corresponding operating components of the system. An association structure describes many-to-many relationships among the components. Targeted requests for information about first objects are satisfied by obtaining information from a first object structure as well as information about associated objects from the second object structure. Bulk requests for information about a large number of objects are handled differently, using a lookup structure that associates the first objects with limited information of the associated second objects, such as externally visible names which would be meaningful to a requestor. Thus response can efficiently provide full information about all first objects as well as limited but useful information about all associated second objects, avoiding traversals of the association structure and corresponding interrogations of the second object structure.

Software Engineering Design: Theory and Practice

Abstract: Introduction to Software Engineering Design Engineering Design Engineering Problem Solving Initial State Operational State Thinking about the Problem Problem Solution Goal State Software Engineering Design Why Study Software Engineering Design? Reasons for Studying Software Design in Product Development Reasons for Studying Software Design in Project Management Software Design Challenges Design Challenge 1: Requirements Volatility Design Challenge 2: Process Design Challenge 3: Technology Design Challenge 4: Ethical and Professional Practices Design Challenge 5: Managing Design Influences Stakeholders Development Organization's Structure Context of Software Design Software Design Process Software Architecture Detailed Design Interface Design Component Design Construction Design Human-Computer Interface Design Software Design Documentation Software Design Management Roles of the Software Designer Systems Engineer Software Architect Component Designer Software Design Fundamentals General Software Design Principles Modularization Abstraction Encapsulation Coupling Cohesion Separation of Interface and Implementation Completeness and Sufficiency Practical Software Design Considerations Design for Minimizing Complexity Design for Change Software Design Strategies Structured Design Object-Oriented Design Software Design with Unified Modeling Language What Is UML? Why Study UML? The UML's Fundamentals Structural Modeling Component Diagrams Logical versus Physical Components Class Diagrams Classes Name Compartment Attribute Compartment Operation Compartment Relationships Dependency Association Aggregation Composition Generalization Realization Deployment Diagrams Behavioral Modeling Use Case Diagrams Interaction Diagrams Communication Diagrams Sequence Diagrams Concurrency in Interaction Diagrams Principles of Software Architecture What Is Software Architecture? Why Study Software Architecture? Key Tasks in Architectural Design Identifying Stakeholders' Concerns Identifying Appropriate Architectural Views Identifying Architectural Styles and Patterns Identifying System Interfaces Identifying Impact of Architectural Decisions in Organization Impact on Customer Base Impact on Budget and Schedule Impact from Resource Availability Identifying the System's Major Components and Interfaces Evaluating and Validating the Architecture Introducing Policies for Design Synchronicity Problem Solving in Software Architecture Inputs Constraints Outputs Software Architecture Process Understand and Evaluate Requirements Elicitation Requirement Sources Elicitation Techniques Analysis Specification and Validation Specific Correct Complete Consistent Attainable Verifiable Designing the Architecture The 4 + 1 View Model User View Process View Physical View Development View Logical View Components and Connectors Designing Logical Architectural Elements Using Data Flows Designing Logical Architectural Elements Using Styles and Patterns Designing the Process Architecture Processes Threads Evaluating the Architecture Patterns and Styles in Software Architecture Architectural Styles and Patterns History of Architectural Styles and Patterns Architectural Pattern Classification Data-Centered Systems Blackboard Pattern Data Flow Systems Pipe and Filter Pattern Distributed Systems Client-Server Pattern Broker Pattern Interactive Systems Model-View-Controller Pattern Hierarchical Systems Main Program and Subroutine Layered Pattern Principles of Detailed Design What Is Detailed Design? Key Tasks in Detailed Design Detailed Design Process Understanding the Architecture and Requirements Creating Detailed Designs Interface Design External Interface Design Internal Interface Design Graphical User Interface Design Designing Internal Structure of Components Classes Interfaces, Types, Subtypes, Dynamic Binding, and Polymorphism Objects Design Principles for Internal Component Design Open-Closed Principle Liskov Substitution Principle Interface Segregation Principle Programming Styles in Detailed Design Function Names Variable Names Modeling Internal Behavior of Components Design Components Using Design Patterns Architectural versus Design Patterns Classification of Design Patterns Documenting Design Patterns Document the Software Design Interface Control Document Software Version Document Monitor and Control Implementation Creational Design Patterns in Detailed Design Creational Design Patterns Abstract Factory Problem Structure Implementation Benefits Factory Method Problem Structure Implementation Benefits Builder Problem Structure Implementation Benefits Prototype Problem Structure Implementation Benefits Singleton Problem Structure Implementation Benefits Structural and Behavioral Patterns in Detailed Design Structural Design Patterns Adapter Problem Structure Implementation Benefits Composite Problem Structure Implementation Benefits Facade Problem Structure Implementation Benefits Behavioral Design Patterns Iterator Problem Structure Implementation Benefits Observer Problem Structure Implementation Benefits Principles of Construction Design What Is Construction Design? Why Study Construction Design? Behavioral Construction Design Flow-Based Designs State-Based Designs Table-Based Designs Limited-Entry Decision Table Extended-Entry Decision Table Mixed-Entry Decision Table Table-Based Construction Programming Design Language Software Construction Using Styles Formatting Conventions Indentation Brace Placement Naming Conventions Documentation Conventions Documenting Files Documenting Functions Minimizing Complexity in Construction Design Quality Evaluation of Construction Design Peer Reviews Unit Testing Cyclomatic Complexity Human-Computer Interface Design Jacob Somervell What Is Human-Computer Interface Design? Why Study Human-Computer Interface Design? General HCI Design Principles Human-Computer Interface Design Methods Getting Started Fidelity in Prototypes Metaphors Gestalt Principles Reusing Earlier Designs Evaluation of HCI Quality Usability Testing Analytic Testing Empirical Testing Software Design Management, Leadership, and Ethics Luis Daniel Otero What Is Software Design Management? Why Study Design Management? The Concept of Quality Design Management Framework Planning Design Efforts Scoping Work Breakdown Structure Budgeting Organizing Linear Responsibility Chart Scheduling with Gantt Charts and Network Diagrams Probability of Time to Completion Establish Change Control Policy Implementation Phase Earned Value Management Termination Stage Leading the Design Effort Personality Traits and Leadership Personality Dimensions Traits of Effective Leaders Ethical Leadership Power Key Leadership Skills Communication Skills Networking Skills Motivation Skills Negotiation Skills Ethics in Software Design Public and Product Principles Judgment Principle Management Principle Index Each chapter includes chapter objectives, a conceptual overview, summary , exercises, and references

MetricAttitude: a visualization tool for the reverse engineering of object oriented software

Abstract: In this paper, we present a visualization approach for the reverse engineering of object-oriented (OO) software systems and its implementation in MetricAttitude, an Eclipse Rich Client Platform application. The goal of our proposal is to ease both the comprehension of a subject system and the identification of fault-prone classes. The approach graphically represents a suite of object-oriented design metrics (e.g., Weighted Methods per Class) and "traditional" code-size metrics (e.g., Lines Of Code). To assess the validity of MetricAttitude and its underlying approach, we have conducted a case study on the framework Eclipse 3.5. The study has provided indications about the tool scalability, interactivity, and completeness. The results also suggest that our proposal can be successfully used in the identification of fault-prone classes.

Named object view over multiple files

Abstract: A named object view report is generated from different electronic object sources. The object sources may be associated with different users and have different access rights. The different object sources from which the objects are obtained may be determined using a variety of methods. A user at a client is presented with the named object view report such that the user's attention is focused on the different objects that are obtained from the different object sources as if the objects were obtained from a single object source. The user may be used to cycle through the objects that are obtained from the different object sources. When an object is edited within the report by a user that is not associated with the user for editing, that object is copied to an object source that is owned by the user.

Testing system for an integrated software system

Abstract: Systems and methods for testing an integrated software system. A mock object (18) includes an aspect joined to a corresponding object (16) within the integrated software system. The mock object (18) intercepts a method call associated with the corresponding object (16) and routes the method call to one of the corresponding object and programmed behavior associated with the mock object. A testing agent (20) instructs the aspect to route the method call to the one of the method associated with corresponding object (16) and the programmed behavior associated with the mock object (18).

Providing update notifications on distributed application objects

Abstract: The present invention extends to methods, systems, and computer program products for providing update notifications on distributed application objects When a new version of an object is created that another object depends on, a notification can be added to the dependent object to alert a person that manages the dependent object of the creation of the updated object Dependent objects can include template objects, such as virtual machine template objects that refer to virtual disk objects and service template objects that refer to one or more virtual machine template objects, as well as service instance objects that represent service instances that are instantiated from template objects Versions of objects within a family can be identified by sharing a family name and having different releases A timestamp is used to represent when an object is released to determine which version of an object is the newest version in a family

Design Strategy and Software Design Effectiveness

Abstract: Software design is about a sequence of steps taken to achieve a goal. Designers must plan their approach to carrying out these steps. In studying designers at work, the authors observed breadth- versus depth-first approaches to design-space exploration and problem- versus solution-driven approaches during the actual design. Which approaches and when to use them are important to effective design. The authors suggest four archetypical strategies that designers can choose under different circumstances, thus making design strategy one of the early design decisions.

Schemes for connecting to wireless network

Abstract: Technology is disclosed for preventing classification of objects, e.g., in an augmented reality system. The technology can identify a set of objects to be classified, determine whether context information for one or more objects in the identified set of objects to be classified is identified as not to be employed during classification, and during classification of two different objects, include context information for one object but not the other.

Software module object analysis

Abstract: In one implementation, an object analysis system identifies an object within a software module, and determines a size of the object based on at least one operation within the software module. The object analysis system identifies the object and determines the size of the object without reference to source code of the software module.

Generation of synthetic context objects

Abstract: A processor-implemented method, system, and/or computer program product generates and utilizes synthetic context-based objects. A non-contextual data object is associated with a context object to define a synthetic context-based object, where the non-contextual data object ambiguously relates to multiple subject-matters, and where the context object provides a context that identifies a specific subject-matter, from the multiple subject-matters, of the non-contextual data object. The synthetic context-based object is then associated with at least one specific data store, which includes data that is associated with data contained in the non-contextual data object and the context object. A request for a data store that is associated with the synthetic context-based object results in the return of at least one data store that is associated with the synthetic context-based object.

Controlling objects in a virtual environment

Abstract: Methods, systems, and computer-storage media having computer-usable instructions embodied thereon, for controlling objects in a virtual environment are provided. Real-world objects may be received into a virtual environment. The real-world objects may be any non-human object. An object skeleton may be identified and mapped to the object. A user skeleton of the real-world user may also be identified and mapped to the object skeleton. By mapping the user skeleton to the object skeleton, movements of the user control the movements of the object in the virtual environment.

Impact of Coupling and Cohesion in Object-Oriented Technology

Abstract: The interaction between the classes or within the classes shows the complexity of the design For one smaller problem, there may be more than one software design but who will be the best; depends on the complexity level of software design Therefore, coupling and cohesion which shows the interlinking of classes and strength of classes; control the complexity of the design The best software object oriented design is based upon the low coupling and high cohesion level In the present work, a real case study of Life Insurance policy for handicapped person is demonstrated through the UML Class Diagram; coupling and cohesion levels are measured and results are demonstrated in the form of tables