Low-Cost Animated Graphics System (LAGS)

The document begins by highlighting the limitations of existing animation systems. Most current systems require users to painstakingly create each frame individually, a process that's both time-consuming and expensive. This project proposes a novel approach to address this shortcoming by developing a 'low-cost animated graphics system'. The goal is to enable the generation of numerous frames automatically using computer assistance rather than manual creation. The system intends to be a significant improvement, creating animation sequences efficiently. This is a stark contrast to existing high-end systems like the Bosch FGS4000, which, at $750,000, is far beyond the reach of many potential users. On the other hand, low-cost micro-based solutions prove inadequate for the storage and processing demands of complex animation. This low-cost animation software seeks to fill the gap between these extremes, making professional-quality animation accessible to a broader range of users.

The primary target users for this low-cost animation system are advertising agencies, but the system's versatility suggests many other applications. The document specifically mentions educational television programs as a potential area where this 2D animation software would be beneficial. The project aims to develop a system that is easy to use and requires minimal effort from the user. By providing pre-built objects, the need for users to create every element from scratch is eliminated. This focus on user-friendliness and ease of use is intended to make animation sequence generation a simpler and more accessible process. The animation software will allow users to generate complete animation sequences without the need to build each frame manually. This focus on user experience is key to widening the appeal of the system and increasing the market for this low-cost animation system.

The document contrasts the proposed system with existing solutions at both ends of the cost spectrum. High-end systems like the Bosch FGS4000, costing $750,000, are prohibitively expensive for most users. These systems generally consist of powerful, high-resolution graphics computers and hardware-driven animation devices. The other end of the spectrum includes cheap systems, such as those based on the Apple III microcomputer. However, these lack the features and storage capabilities necessary to create complex, high-quality animation sequences. Therefore, the proposed system seeks to provide a solution that's both affordable and powerful enough to meet the needs of users interested in 2D animation. It strikes a balance between cost and functionality, offering an accessible alternative for those seeking efficient animation sequence generation and a user-friendly design. This makes this new animation software solution a potentially valuable addition to the market, filling a significant gap in currently available options.

The decision to utilize a decentralized system architecture is central to optimizing the system for interactive animation. Two options were considered: a centralized system with all users linked to a central computing facility, and a decentralized system where each user has their own installation. The centralized approach was rejected due to reliability concerns (a single point of failure) and the inherent limitations of timesharing systems for real-time, comprehensive graphics. Timesharing can lead to frequent pauses in the animation due to timeslicing. The decentralized model, where each user has their own computer, avoids these problems and allows users to leverage their existing hardware, minimizing the initial investment cost and enhancing the responsiveness crucial for interactive animation. This choice is vital for providing a smooth and efficient interactive animation experience, a key selling point of the animation software.

With a decentralized architecture, the choice of hardware for each user becomes significant. The document notes that expensive mainframes are unnecessary and likely unaffordable for many users, such as advertising agencies. The project focuses on 2D animation, and this limitation streamlines the required hardware specifications, making it more accessible. The choice between batch processing and interactive processing is a key consideration. Batch processing, while potentially more efficient for simple tasks, is deemed unsuitable for the intended interactive animation system because of the considerable delay between task initiation and result visualization. In contrast, interactive processing offers almost immediate feedback, crucial for a responsive user experience. However, the document acknowledges that the time to animate increases as the complexity of the objects in the animation grows. This trade-off between immediate feedback and performance with complex objects needs to be managed within the system design. The system prioritizes interactive processing despite the speed limitations at higher complexity levels, understanding that immediate feedback enhances the interactive animation workflow.

To further enhance speed and responsiveness in interactive animation, two approaches were explored for designing an interactive system. The first involved interpreting commands and producing high-quality output codes to a file, which can then be displayed at maximum speed. While limited by hardware capabilities, this approach prioritizes playback speed after initial processing. The second approach focuses on reducing the processing load during real-time animation. This might involve using an existing graphics package to handle basic object representation and drawing commands; however, the actual animation commands would still need to be designed. This approach is geared towards delivering a highly responsive interactive animation experience by minimizing processing during the animation process itself. The system design balances these considerations to optimize the balance between speed and responsiveness of the interactive animation feature.

The core of the animation software is the LAGS language, designed for user-friendliness and efficiency. A key design goal was to create concise commands capable of performing complex animation transformations. This allows users to achieve sophisticated results without overly complex code. The language's structure also prioritizes ease of use and an understandable user interface. The choice to avoid using tools like parser generators was made after considering the development time required to learn the necessary grammars, the difficulties of updating the language for users unfamiliar with those grammars, and portability issues arising from dependence on specific tools. The focus remains on creating efficient and readily understandable code for the LAGS language, thus improving accessibility and simplifying the process of creating animation sequences.

A critical aspect of the animation software design is achieving terminal independence. This involves determining the appropriate level of terminal-dependent graphics primitives. Three key points guided the decision: the importance of developing very low-level primitives (considering the extra work required for higher-level routines), the expected speed of graphics terminals, and the effect of the level of primitives on real-time animation speed. After weighing these factors, the decision was made to utilize a fast and efficient graphics terminal, delegating basic primitives like plotting, line drawing, and screen clearing to the terminal itself. More complex primitives, such as circle and arc drawing, were also designed to be terminal-independent, ensuring better compatibility and portability for the animation software and improving the efficiency of the animation sequence generation process across different hardware.

LAGS commands are categorized as either graphic or non-graphic. Non-graphic commands manage entities within the system, allowing users to add, remove, or query objects and manage files. Graphic commands directly influence the visual aspects of the animation. A critical aspect highlighted is the 'transfer' command, which moves an object along a defined path over several frames. This path can be a straight line or a more complex curve defined by a coordinate sequence. The design of LAGS prioritizes concise commands, simplifying the user interaction and enabling complex animation transformations with minimal code. This design enhances both usability and efficiency, making the creation and modification of animation sequences more intuitive and streamlined. The choice of a user-friendly interface enhances accessibility to this animation software.

Objects within the system are stored as a sequence of commands that draw the object. A crucial addition to the object definition is a structure that points to all the numbers embedded within these commands. This design choice significantly improves animation efficiency. Modifying object parameters during animation becomes much faster because there's no need to scan and identify each command within the object definition. Instead, the system can directly access and modify the necessary parameters through this pointer structure. This optimized storage and access method is key to improving the speed and smoothness of animation sequences generated by the system. This efficient method is especially crucial for complex objects, contributing to the overall performance of the animation software.

The system's animation technique relies on pre-calculating ten constants before an animation sequence begins. This allows for frame-by-frame transformation of objects with minimal computation during the actual animation playback. Once the constants are calculated, the animation flows smoothly, reducing lag and improving responsiveness. Objects are animated by modifying the parameters of the commands defining the object—a process simplified by the 'list of pointers to numbers' accompanying each object definition. The use of pre-calculated constants significantly reduces the computational burden during real-time animation, enabling smoother and more fluid animation sequences. This efficient method makes the system suitable for applications requiring a high degree of animation smoothness and responsiveness.

The system stores objects using absolute coordinates rather than relative coordinates. This is essential because object parameters change during animation. Relative commands are converted to absolute coordinates during object definition. The system incorporates curve-fitting algorithms to handle both function-generated points and point sequences defining object paths. Curve fitting ensures smooth transitions between points during animation. For ellipses, a curve-fitting algorithm is utilized due to its efficiency and precision. This ensures that the animation process produces smooth and visually appealing results, even when dealing with complex curves and object movements. The efficient management of object transformations is critical to the system's performance and overall animation quality. The use of curve-fitting addresses a crucial aspect of smooth animation sequence generation.