基于三维实体模型的钢结构工业厂房CAD/CAM软件后处理系统

为提高钢结构工业厂房设计的准确性、精确度和工作效率,为某钢结构工业厂房CAD/CAM软件研制出基于三维实体模型的后处理系统.该系统基于面向对象的编程技术,抽象出描述实际结构零件几何信息、结构特征和设计条件的智能型实体对象.将对象以及对象之间的层次关系和逻辑关系存储在AutoCAD图形数据库中,形成三维实体模型,用于直观、准确和完整地表现具有复杂空间关系和细部构造的真实结构;实现数据库对象的建立、编辑、查询、显示和数据整理等操作.该系统结合具体结构形式的特点,实现用于施工图设计和深化设计的全部关键功能.     

Design, construction, and application of a generic visual languagegeneration environment

The implementation of visual programming languages (VPLs) and their supporting environments is time-consuming and tedious. To ease the task, researchers have developed some high-level tools to reduce the development effort. None of these tools, however, can be easily used to create a complete visual language in a seamless way as the lex/yacc tools do for textual language constructions. This paper presents the design, construction and application of a generic visual language generation environment, called VisPro. The VisPro design model improves the conventional model-view-controller framework in that its functional modules are decoupled to allow independent development and integration. The VisPro environment consists of a set of visual programming tools. Using VisPro, the process of VPL construction can be divided into two steps: lexicon definition and grammar specification. The former step defines visual objects and a visual editor, and the latter step provides language grammars with graph rewriting rules. The compiler for the VPL is automatically created according to the grammar specification. A target VPL is generated as a programming environment which contains the compiler and the visual editor. The paper demonstrates how VisPro is used by building a simple visual language and a more complex visual modeling language for distributed programming     

COCOVILA – Compiler-Compiler for Visual Languages

A compiler-compiler for visual languages is presented. It has been designed as a framework for building visual programming environments that translate schemas into textual representation as well as into programs representing the deep meaning of schemas. The deep semantics is implemented by applying attribute grammars to schema languages; attribute dependencies are implemented as methods of Java classes. Unlike compiler-compilers of textual languages, a large part of the framework is needed for support of interactive usage of a visual language.     

Compiler support for general-purpose computation on GPUs

In recent years, the GPU (graphics processing unit) has evolved into an extremely powerful and flexible processor, with it now representing an attractive platform for general-purpose computation. Moreover, changes to the design and programmability of GPUs provide the opportunity to perform general-purpose computation on a GPU (GPGPU). Even though many programming languages, software tools, and libraries have been proposed to facilitate GPGPU programming, the unusual and specific programming model of the GPU remains a significant barrier to writing GPGPU programs. In this paper, we introduce a novel compiler-based approach for GPGPU programming. Compiler directives are used to label code fragments that are to be executed on the GPU. Our GPGPU compiler, Guru, converts the labeled code fragments into ISO-compliant C code that contains appropriate OpenGL and Cg APIs. A native C compiler can then be used to compile it into the executable code for GPU. Our compiler is implemented based on the Open64 compiler infrastructure. Preliminary experimental results from selected benchmarks show that our compiler produces significant performance improvements for programs that exhibit a high degree of data parallelism.     

The separation principle: A programming paradigm

In the development of any technology, there's always a tendency to lose sight of the basic problems that stimulated its introduction in the first place. Technologies in software construction are no exception. One of the essential parts of software construction is the underlying programming paradigm. In the last few decades, different software construction paradigms have evolved - for example, structured programming in the 1970s and object-oriented programming in the 1980s. Although OOP dominates current software construction, it introduces several problems that might raise questions about its understandability and efficiency. W. Cave (1995) was the first to propose and develop the separation principle as a programming paradigm. One major contribution is that it moves most complex issues related to data sharing, parameter passing, and scope into a programming model in which simple graphics can represent access to data. The separation principle can simplify or even eliminate these issues. By expressing access permissions in simple, canonical drawings, the separation principle makes it easy to comprehend the full range of relationships between data and instructions, and thus the code's structure. A simple way to show connectivity, a key property affecting program understandability, is by separating data from instructions. Two of prediction systems' flagship products, the visual software environment (VSE) and the general simulation system (GSS), embody this idea. This paper discusses the separation principle in the context of conventional languages such as C and C++.     

A Classification Framework to Support the Design of Visual Languages

An important step in the design of visual languages is the specification of the graphical objects and the composition rules for constructing feasible visual sentences. The presence of different typologies of visual languages, each with specific graphical and structural characteristics, yields the need to have models and tools that unify the design steps for different types of visual languages. To this aim, in this paper we present a formal framework of visual language classes. Each class characterizes a family of visual languages based upon the nature of their graphical objects and composition rules. The framework has been embedded in the Visual Language Compiler–Compiler (VLCC), a graphical system for the automatic generation of visual programming environments.     

可视化语言技术在软件开发中的应用

可视化语言技术比一维文本语言在描述软件组成方面具有优越性.由于图表和图形概念在系统建模中的广泛使用,可视化语言可以应用于需求分析、设计、测试和维护等软件开发的各个阶段.除了具有直观易见的特点之外,图文法在计算机上的精确建模和验证能力,为设计可视化语言提供了一个坚实的理论基础.讨论了可视化语言的形式理论基础,回顾了相关的可视化图形编程环境.特别提出了一种空间图文法,并且用该图文法定义了统一建模语言的行为语义.基于空间图文法,开发了一种基于模式驱动的框架,以帮助软件架构与设计.     

Environment for rapidly creating interactive design tools

The Garnet toolkit was specifically designed to make highly interactive graphical programs easier to design and implement. Visual, interactive, user-interface design tools clearly fall into this category. At this point, we have used the Garnet toolkit to create three different interactive design tools: Gilt, a simple interface builder for laying out widgets; Lapidary, a sophisticated design tool for constructing application-specific graphics and custom widgets; and C32, a spreadsheet interface to constraints. The features of the Garnet toolkit that made these easier to create include use of a prototype-instance object system instead of the usual class-instance model, integration of constraints with the object system, graphics model that supports automatic graphical update and saving to disk of on-screen objects, separation of specifying the graphics of objects from their behavior, automatic layout of graphical objects in a variety of styles, and a widget set that supports such commonly used operations as selection, moving and growing objects, and displaying and setting their properties.     

Programs as visual,interactive documents

We present a novel approach to combined textual and visual programming by allowing visual, interactive objects to be embedded within textual source code and segments of source code to be further embedded within those objects. We retain the strengths of text‐based source code, while enabling visual programming where it is beneficial. Additionally, embedded objects and code provide a simple object‐oriented approach to adding a visual form of LISP‐style macros to a language. The ability to freely combine source code and visual, interactive objects with one another allows for the construction of interactive programming tools and experimentation with novel programming language extensions. Our visual programming system is supported by a type coercion‐based presentation protocol that displays normal Java and Python objects in a visual, interactive form. We have implemented our system within a prototype interactive programming environment called ‘The Larch Environment’. Copyright © 2013 John Wiley & Sons, Ltd.     

A visual representation of cellular automata-like systems

Cellular automata (CA) models and corresponding algorithms have a rich theoretical basis, and have also been used in a great variety of applications. A number of programming languages and systems have been developed to support the implementation of the CA models. However, these languages focus on computational and performance issues, and do not pay enough attention to programming productivity, usability, understandability, and other aspects of software engineering.In this paper, we describe a new special-purpose programming language developed for visual specification, presentation, and explanation of CA systems within a visual programming environment, as well as, for programming them. This language is based on using visual patterns, colors, and animation for representing the CA system structures and operations on these structures, and for performing editing and composing manipulations with corresponding software components. Examples of the CA algorithm representations and some details of the environment implementation are presented.     

基于询问-回答模式的对象控制模型的实现

在诸多系统设计中，系统需要管理大量具有内在关联性相似性的对象系统（通常表现为对象树或对象图的形式）。通常采用的方法是系统集中管理和控制，根据对象的互异性特征，选取指定的对象和决定对象如何访问。这种集中控制的弊端是管理复杂、成本高，容易造成错误，并且可扩充性差。文章介绍了一种基于询问-回答模式的对象控制模型，有效地解决了这个问题。     

Interpretive Tools for 3-D Structural Geological Modeling Part I: Bézier-Based Curves, Ribbons and Grip Frames

Interpreting the geometry of geological objects is a standard activity of field-based geologists. We present new graphics tools that will aid in extending this activity from 2-D geological mapping into a 3-D environment. Much of the existing 3-D geological modeling software supports the construction of objects with the input of dense control data. However, for regional mapping and near mine exploration work, sparse data is the norm. Tools are required therefore, which give the expert interpreter full control of the graphics objects, while at the same time constraining interpretations to specific control data from field observations. We present the initial results of a software design and programming project for the visualization of complex regional scale geologic objects using Bézier-based graphics tools that are optimized for sparse data interpretation. We also introduce the concept of a structural ribbon, which is a 3-D extended map trace, along with methods for the optimization of surface construction using graphical grip frames.     

RasterCalc: Calculus for Operations on Graphics Colour Rasters

An extended model and calculus, called RasterCalc, is presented for operations on discrete graphics rasters, including their colour functions. The operations are separated into two main categories: operations on domains, and operations on colour functions. The operations are further classified as local and remote, depending on the correspondence between destination and source pixels. The new raster element or pixel can be a function of a single element from one or more rasters, a function of a small area from other rasters, or a function of entire rasters. Local operations have their main applications in computer graphics, while remote operations are more oriented towards image processing. A mathematically oriented notation is used to define and represent the operations included. RasterCalc has been implemented as a procedure package in Pascal, to be used on a powerful, yet expensive display. Recently a C version has been completed for a personal colour computer with a special chip for raster operations. The work reported in this paper is partially supplied by the Dutch Technical Sciences Foundation, under project number LWI 14.0130: “Facilities for raster graphics in programming languages”     

HAGI, a High-level Application/Graphics Interface

HAGI is an object-oriented graphics system developed on top of the X window system. In addition to providing facilities that structured graphics systems such as GKS usually have, HAGI supports a high- level graphics paradigm with the following features:

• + In addition to graphical objects, the system provides a class of application objects with a higher level of abstraction than graphical objects.
• + Graphics manipulation operations can be issued simplyfrom application objects without explicitly referring to specific graphical objects. Thus graphics manipulation appears to be transparent to application programmers.
• + Graphical objects are designed to encompass more semantics, thus are at a level close to the application. For example, they useflexible visual objects to determine their visual appearance.

HAGI provides such a high-level application/graphics interface by maintaining a dependency relationship between graphical objects and application objects.     

Software Systems for Computer Graphics

This paper describes some software packages and programming systems for computer graphics applications, in the process considering software features for both passive and interactive graphics. It examines the structure both of subroutine libraries for use with some base language and of complete programming languages, and outlines the advantages and disadvantages of each, along with facilities that should be present in any software package.     

Cognitive Factors in Programming with Diagrams

Visual programming languages aim to broaden the use ofdiagrams within the software industry, to the extentthat they are integrated into the programming languageitself. As a result, they provide an ideal opportunityto study the benefits of diagrams as an externalrepresentation during problem solving: not only isprogramming a challenging problem-solving activity,but the effect of diagram usage can be directlyassessed by comparing performance while using a visualprogramming language to performance with a standardtextual language. There have been severalmisconceptions amongst visual language researchersregarding the role of diagrams in software design, butthese are being addressed by empirical studies and bynew theories of notation design derived from studiesof visual programming. Based on this research, theauthors are able to recommend several new directionsfor research into thinking with diagrams.     

Visual Depiction of Decision Statements: What is Best for Programmers and Non-Programmers?

This paper reports the results of two experiments investigating differences in comprehensibility of textual and graphical notations for representing decision statements. The first experiment was a replication of a prior experiment that found textual notations to be better than particular graphical notations. After replicating this study, two other hypotheses were investigated in a second experiment. Our first claim is that graphics may be better for technical, non-programmers than they are for programmers because of the great amount of experience that programmers have with textual notations in programming languages. The second is that modifications to graphical forms may improve their usefulness. The results support both of these hypotheses.