Vector Object Scaling via Grid Segmentation and Code Generation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graphical application development environments face challenges in automating the scaling of arbitrarily complex graphical objects, as conventional methods like nine slicing require extensive programming and can result in undesirable graphical effects such as 'jagged' appearances when using bitmap magnification.
Innovation Solution
A grid of four guide lines is superimposed on a graphical object, allowing users to control transformations, and overlapping vectors are divided into separate section vectors, with transformation code generated to ensure the object's outline is maintained during scaling, resulting in a sharper transformed representation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Extent of automation
If nine slice scaling is implemented manually with programming, then scaling transformation can be achieved, but the process requires extensive programming time and expert skills
Solution Approach 1:
The system automatically generates scaling transformation code by analyzing the graphical object's vectors and grid sections, eliminating the need for manual programming. The code generation module self-services by creating the necessary transformation matrices and scaling logic based on the object's geometric properties and the desired scaling parameters.
Solution Approach 2:
The patent replaces manual mechanical programming processes with an automated computational system. Instead of requiring developers to manually write transformation code, the system uses algorithms to automatically calculate and generate the scaling transformation matrices, substituting human effort with automated mathematical computation.
2Extent of automation
If bitmap magnification is used for scaling, then automation is easier to implement, but the graphical quality degrades with jagged appearances
Solution Approach 1:
The patent segments the graphical object into nine distinct sections based on a grid overlay, allowing each section to be scaled independently using vector mathematics. This segmentation enables precise control over the scaling of different parts of the object, maintaining sharp edges and smooth curves while achieving automated scaling transformation.
Solution Approach 2:
The system changes the representation parameter from bitmap pixels to vector coordinates, allowing scaling to be performed through mathematical transformation of control points and bezier curves. This parameter change from raster to vector domain enables automated scaling without quality degradation, as vectors can be scaled infinitely without loss of precision.
3Manufacturing precision
If vector graphics are used for scaling, then graphical quality is maintained, but the computational complexity increases due to arbitrary object shapes
Solution Approach 1:
The patent divides complex vector objects into nine manageable sections using a grid system, where each section contains a subset of the original vectors. This segmentation reduces the computational complexity by allowing scaling transformations to be applied to smaller, more manageable vector groups rather than the entire complex object at once.
Solution Approach 2:
The system applies different scaling transformations to different sections of the object based on their local requirements. Each of the nine sections can have its own transformation matrix, allowing the scaling operation to adapt to the local geometric properties of each region while maintaining overall object integrity and visual quality.
4Adaptability or versatility
If nine slice grid lines are made non-symmetrical to fit arbitrary objects, then versatility is improved, but automation becomes highly complex
Solution Approach 1:
The patent implements a dynamic grid system where the nine slice lines can be positioned asymmetrically to accommodate arbitrary object shapes and aspect ratios. The grid configuration adapts dynamically based on the object's dimensions and the desired scaling behavior, allowing the same automated algorithm to handle both symmetric and asymmetric cases without increasing complexity.
Data Source
AI summary
Scaling arbitrarily complex graphical objects is described by superimposing a grid of four guide lines on a graphical object defined by one or more vectors. The guide lines define nine grid sections. The graphical application development environment (GADE) divides any vectors crossing multiple grid sections into separate section vectors, such that each section contains whole vectors. The application and resulting vector information in each grid section is compiled into an executable file. When executed in a compatible run-time container, the container virtually renders a transformed representation of the graphical object in memory. Using information gathered from analyzing the outline of the transformed representation, the run-time container generates code blocks for transforming each of the vectors within the grid sections an appropriate amount that conforms to the outline information. The resulting transformed vectors are displayed in the running application.