Graphical User Interface Framework Research Articles

DEVELOPMENT OF AN APPLICATION AS AN AUXILIARY TOOL FOR VERIFICATION OF AN ELECTROCARDIOGRAM CONCLUSION

Objective: Electrocardiography (ECG) is a key step in the diagnosis of cardiovascular pathology. Interpretation of the ECG is carried out by the doctor in the first minutes of severe patient admission and often determines further tactics of management. However, such an important diagnostic method is quite subjective, since it is highly dependent on the knowledge, and experience of the doctor and even on his attention to detail. The objective is to develop an application for automatic verification of various ECG criteria (exceptionally as an addition to the subjective interpretation of the doctor). Design and method: The desktop application was developed in Python (v3.10.5) by implementing its object-oriented programming concepts. Tkinter was chosen as a Graphical User Interface framework. The set of standard libraries has been supplemented by OpenCV (v4.6.0.66) for recognizing and digitizing ECG images, Pillow (v9.3.0) for manipulating the image and its metadata, NumPy (v1.23.5) for further analysis, and others. The initial version of the program includes STEMI recognition. Real ECGs printed on graph paper were used for debugging and testing. Results: When launching the application, the user is prompted to select a file containing an ECG image (a). After the required image has opened, the user should indicate the requested ECG-leads in the picture, following the simplest instructions (b). Then processing of the leads automatically starts. This phase is hidden from the user, and only a progress bar is displayed on the screen (c). Meanwhile, a number of manipulations are performed, such as converting the picture to a binary state, recognizing the ECG-line, and storing the coordinates of each pixel in the database. Objects of such classes as Isoline, and Cardiac Cycle with R wave, ST segment, etc. are created for each of the objects of the Lead class (d). Further geometric study of the pixel base and checking for the pathological ECG-signs on the backend form the final conclusion for the user (e). Conclusions: The developed application is relevant for use as an additional tool in the work and training of doctors. It can be expanded to cover a wide range of pathologies.

Lessons Learned While Migrating From Swing to JavaFX

The authors describe a case study of the migration of an interactive diagramming tool written in Java from the Swing Graphical User Interface framework to the more recent JavaFX framework. The study distills the authors' experience identifying what information was needed to support the migration effort, and how the information was ultimately discovered. The outcome is presented in a set of five lessons about the discrepancies between expectations and reality in the search for information when migrating software between major frameworks.

A mathematical framework for design and optimization of regenerative storage heater

The Regenerative Storage Heater (RSH) is employed in Hypersonic Wind Tunnel (HWT) to prevent liquefaction of air during expansion in the high Mach number nozzles. Design of RSH is a multi-variable iterative process depends on the total energy required, the exit temperature of the air and the duration of blowdown. Arriving at the optimal design of RSH is essential as it has a high economic impact. After arriving at the design, evaluation of the performance of RSH for all the possible operating conditions prior to manufacturing is critical. The current research work addresses the challenge by evolving a mathematical framework using multi-objective optimization functions. MATLAB based integrated Graphical User Interface (GUI) has been developed to study the design and analysis simultaneously. This GUI framework defines the inputs, constraints and the parameters of optimal design for the RSH and calculates the optimal size of the RSH. The paper presents the details of the size of the heater for multi hole multi brick configuration in the RSH for a given input conditions of a Mach 5.0 wind tunnel heater case. The current research also presents the details of the temperature profiles of the bed during heating and blowdown cycles. Finally, framework has been used to design the heater for one of the known published data. It is found that the predicted performance of RSH is in good agreement with the published data. This has established the accuracy of the developed framework.

Development of State Estimation Filter Simulator Built on an Integrated GUI Framework

We have developed a graphical user interface (GUI)-based state estimation filter simulator (called StefAny) that makes it easy to understand and compare the behaviors of filters such as Kalman filters (KFs) and particle filters (PFs). The key feature of StefAny is to show, when a system designer applies a PF, a detailed graph representing the relationship among the distribution and weights of all particles on any arbitrary timeline through simulation. Moreover, the timeline can be specified on another graph showing an estimated time series for each filter. These features enable system designers to easily check the compatibility between a filter and a target distribution, which determines the state estimation accuracy. In this paper, we present the functions of StefAny and demonstrate in detail how StefAny facilitates understanding of the properties of filters via a compatibility check comparison experiment for PFs, point estimation methods, and distributions.

Instrumentino: An Open-Source Software for Scientific Instruments.

Scientists often need to build dedicated computer-controlled experimental systems. For this purpose, it is becoming common to employ open-source microcontroller platforms, such as the Arduino. These boards and associated integrated software development environments provide affordable yet powerful solutions for the implementation of hardware control of transducers and acquisition of signals from detectors and sensors. It is, however, a challenge to write programs that allow interactive use of such arrangements from a personal computer. This task is particularly complex if some of the included hardware components are connected directly to the computer and not via the microcontroller. A graphical user interface framework, Instrumentino, was therefore developed to allow the creation of control programs for complex systems with minimal programming effort. By writing a single code file, a powerful custom user interface is generated, which enables the automatic running of elaborate operation sequences and observation of acquired experimental data in real time. The framework, which is written in Python, allows extension by users, and is made available as an open source project.

Instrumentino: An open-source modular Python framework for controlling Arduino based experimental instruments

Instrumentino is an open-source modular graphical user interface framework for controlling Arduino based experimental instruments. It expands the control capability of Arduino by allowing instruments builders to easily create a custom user interface program running on an attached personal computer. It enables the definition of operation sequences and their automated running without user intervention. Acquired experimental data and a usage log are automatically saved on the computer for further processing. The use of the programming language Python also allows easy extension. Complex devices, which are difficult to control using an Arduino, may be integrated as well by incorporating third party application programming interfaces into the Instrumentino framework. Program summaryProgram title: Instrumentino, ControlinoCatalogue identifier: AETJ_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AETJ_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: GNU General Public License, version 3No. of lines in distributed program, including test data, etc.: 17097No. of bytes in distributed program, including test data, etc.: 3425023Distribution format: tar.gzProgramming language: Python, C.Computer: i386, x86-64.Operating system: Linux, Mac OS X, Windows.RAM: 60 MBClassification: 16.4.External routines: wxPython, pySerial, matplotlib, agw (Instrumentino), SoftwareSerial (Controlino)Nature of problem:Control and monitor purpose-made experimental instrumentsSolution method:Modular Graphical User Interface for hardware controlRunning time:Depends on the user.

Empirical analysis of GUI programming concerns

The focus of this paper is on identification of typical graphical user interface (GUI) programming concerns. As opposed to some other proposals available in the literature that indicate GUI programming concerns by simple intuition, we have conducted a systematic empirical analysis to derive our proposal. It included an analysis of an existing application programming interface (API), its use in industrial projects, and an analysis of the requirements and issues reported during software maintenance. In addition, we have evaluated more than 50 GUI frameworks and APIs and proved usefulness and generality of our classification of concerns. As an additional proof of applicability of the proposed classification, we have refactored the inheritance hierarchy of the selected GUI API using concern-oriented interfaces. We have implemented a supporting tool that complements the developed API and supports its concern-oriented use. The evaluation of the refactored API showed positive effects on API usability.

A GUI (Graphical User Interface) framework to Introduce H-H Model in Comparison with Kv3.3 Model

The technique of modeling a neuron is mandatory and complex. In this paper, we introduce a simulating window by using graphical user interface (GUI) and it also helps researches in learning Hodgkin-Huxley (HH) complex mathematical equations. By using such type of simulator, users can build any panel for easy analysis and visualization of results. Therefore, here we discuss this type of panel for H-H model in comparison with Kv3.3 model that motivates to propose a new version of neuron modeling.

Research on 3D Visualization Framework via CEGUI in OGRE Engine

By using high-performance graphics rendering engine, Graphical User Interface (GUI) technology is introduced for the interactive mechanism to develop the visualization system. GUI provides users with an intuitive interaction interface and plays an important role in 3D visualization. 3D visualization development gradually demands lightweight GUI framework with suitability, flexibility and extensibility. This paper presents a lightweight 3D visualization framework via Crazy Eddie's Graphical User Interface (CEGUI) in OGRE engine, and illustrates its detailed architecture and component. Finally the animations with CEGUI and OGRE are implemented.

Framework for Graphical User Interfaces of Geospatial Early Warning Systems

An important component of Early Warning Systems (EWS) for man-made and natural hazards is the command and control unit’s Graphical User Interface (GUI). All relevant information of an EWS is concentrated in this GUI and offered to human operators. However, when designing the GUI, not only the user experience and the GUI’s screens are relevant, but also the frameworks and technologies that the GUI is built on and the implementation of the GUI itself are of great importance. Implementations differ based on their applications in different domains but the design and approaches to implement the GUIs of different EWS often show analogies. The design and development of such GUIs are performed repeatedly on some parts of the system for each EWS. Thus, the generic GUI framework of a geospatial EWS for tsunamis is introduced to enable possible synergistic effects on the development of other new related technology. The results presented here could be adopted and reused in other EWS for man-made and natural hazards.

Domain Specific High-Level Constraints for User Interface Layout

We present the Auckland Layout Model (ALM), a constraint-based technique for specifying 2D layout as it is used for arranging the controls in a graphical user interface (GUI). Most GUI frameworks offer layout managers that are basically adjustable tables; often adjacent table cells can be merged. In the ALM, the focus switches from the table cells to vertical and horizontal tabulators between the cells. On the lowest level of abstraction, the model applies linear constraints, and an optimal layout is calculated using linear programming. However, bare linear programming makes layout specification cumbersome and unintuitive, especially for GUI domain experts who are often not used to such mathematical formalisms. In order to improve the usability of the model, ALM offers several other layers of abstraction that make it possible to define common GUI layout more easily. In the domain of user interfaces it is important that specifications are not over-constrained, therefore ALM introduces soft constraints, which are automatically translated to appropriate hard linear constraints and terms in the objective function. GUIs are usually composed of rectangular areas containing controls, therefore ALM offers an abstraction for such areas. Dynamic resizing behavior is very important for GUIs, hence areas have domain-specific parameters specifying their minimum, maximum and preferred sizes. From such definitions, hard and soft constraints are automatically derived. A third level of abstraction allows designers to arrange GUIs in a tabular fashion, using abstractions for columns and rows, which offer additional parameters for ordering and alignment. Row and column definitions are used to automatically generate definitions from lower levels of abstraction, such as hard and soft constraints and areas. Specifications from all levels of abstraction can be consistently combined, offering GUI developers a rich set of tools that is much closer to their needs than pure linear constraints. Incremental computation of solutions makes constraint solving fast enough for near real-time use.

GumTree—a Java based GUI framework for beamline experiments

GumTree is a highly integrated multi-platform graphical user interface (GUI) for performing neutron and X-ray scattering experiments. This open source project is built upon the foundation of the Eclipse Rich Client Platform, using the Java programming language. The GumTree Project at ANSTO consists of a general application framework (GumTree Platform) and a set of specific components for the OPAL reactor Neutron Beam Instruments Project (NBIP). The GumTree Platform provides the essential GUI components for common beamline operations via an application programming interface (API) and Eclipse's extension mechanism. GumTree is being adapted to several instrument control server systems, providing an easy-to-use front-end for users and simple-to-extend model for software developers.

An Object-Oriented Modeling Approach in Materials Processing: Case Study of the Acheson and Carburizing Processes

Numerical results can be conveyed effectively to any one using an object-oriented framework. Therefore, it becomes essential to couple the object-oriented approach with numerical analysis. A simple object-oriented methodology for creating a graphical user interface (GUI) as a framework is presented. This work tries to fill a gap between scientific computer code written in a noninteractive way and interactive programming in materials processing. The GUI interface framework has been created in such a way that at any point of time one need not create a new GUI framework. The user only needs to create the process object and attach it to the framework. Two examples have been presented involving interactive finite volume-based gas carburizing and interactive finite difference-based Acheson process (used for the production of silicon carbide).

Frameworks in CS1

In this paper we argue that introducing object-oriented frameworks as subject already in the CS1 curriculum is important if we are to train the programmers of tomorrow to become just as much software reusers as software producers. We present a simple, graphical, framework that we have successfully used to introduce the principles of object-oriented frameworks to students at the introductory programming level. Our framework, while simple, introduces central abstractions such as inversion of control, event-driven programming, and variability points/hot-spots. This has provided a good starting point for introducing graphical user interface frameworks such as Java Swing and AWT as the students are not overwhelmed by all the details of such frameworks right away but given a conceptual road-map and practical experience that allow them to cope with the complexity.

Intermediate Smalltalk (abstract)

Careful design before programming is as important in Smalltalk as in other languages. This tutorial describes techniques that have proven useful in commercial development of large Smalltalk systems. The tutorial shows how to develop a language independent design and then go to detailed programming and testing. The examples will be based on Smalltalk-80 and use the release 4.1 graphical user interface framework.