Ian Chai

Sparse-pixel recognition of primitives in engineering drawings

Recognition of primitives in technical drawings is the first stage in their higher level interpretation. It calls for processing of voluminous scanned raster files. This is a difficult task if each pixel must be addressed at least once, as required by Hough transform or thinning-based methods. This work presents a set of algorithms that recognize drawing primitives by examining the raster file sparsely. Bars (straight line segments), arcs, and arrowheads are identified by the orthogonal zig-zag, perpendicular Bisector tracing, and self-supervised arrowhead recognition algorithms, respectively. The common feature of these algorithms is that rather than applying massive pixel addressing, they recognize the sought primitives by screening a carefully selected sample of the image and focusing attention on identified key areas. The sparse-pixel-based algorithms yield high quality recognition, as demonstrated on a sample of engineering drawings.

An Adaptive And Parameterized Job Grouping Algorithm For Scheduling Grid Jobs

An unorganized deployment of grid applications with a large amount of fine-grain jobs would let the communication overhead dominate the overall processing time, resulting in a low computation-communication ratio. Grids dynamic nature complicates the planning of the job scheduling activity for minimizing the application processing time. This paper presents a grid job scheduling algorithm, based on a parameterized job grouping strategy, which is adaptive to the runtime grid environment. Jobs are grouped based on the job processing requirements, resource policies, network conditions and users QoS requirements. Simulations using the GridSim toolkit reveal that the algorithm reduces the overall application processing time significantly.

Task granularity policies for deploying bag-of-task applications on global grids

Deploying lightweight tasks individually on grid resources would lead to a situation where communication overhead dominates the overall application processing time. The communication overhead can be reduced if we group the lightweight tasks at the meta-scheduler before the deployment. However, there is a necessity to limit the number of tasks in a group in order to utilise the resources and the interconnecting network in an optimal manner. In this paper, we propose policies and approaches to decide the granularity of a task group that obeys the task processing requirements and resource-network utilisation constraints while satisfying the users QoS requirements. Experiments on bag-of-task applications reveal that the proposed policies and approaches lead towards an economical and efficient way of grid utilisation. Highlights? Grouping the fine-grain grid tasks highly reduces the application processing time. ? QoS and the resource-network utilisation constrains affect the size of a task group. ? We present batch resizing policies and techniques to create the task groups. ? Our strategies support both parametric and non-parametric sweep applications. ? Our task group deployment increases the resource utilisation.

Extraction of text boxes from engineering drawings

Textboxes are minimum size rectangles enclosing blocks of text in engineering drawings. Their separation from the graphics surrounding them is a first step in character recognition, and is a part of the Machine Drawing Understanding System, currently under development. Textbox extraction is preceded by orthogonal zig-zag vectorization, arc segmentation, and arrowhead recognition. It is done by clustering the remaining short bars that are located close to each other through a region growing process. Further refinements follow which improve the ability of the process to outline the real textboxes.

On-Line task granularity adaptation for dynamic grid applications

Deploying lightweight tasks on grid resources would let the communication overhead dominate the overall application processing time Our aim is to increase the resulting computation-communication ratio by adjusting the task granularity at the grid scheduler We propose an on-line scheduling algorithm which performs task grouping to support an unlimited number of user tasks, arriving at the scheduler at runtime The algorithm decides the task granularity based on the dynamic nature of a grid environment: task processing requirements; resource-network utilisation constraints; and users QoS requirements Simulation results reveal that our algorithm reduces the overall application processing time and communication overhead significantly while satisfying the runtime constraints set by the users and the resources.

Orthogonal zig-zag: an efficient method for extracting straight lines from engineering drawings

Extracting bars (straight line segments) from a binary image is a first processing step in a system for understanding engineering drawings as well as other applications such as robotics [1]. A novel algorithm — the Orthogonal Zig-Zag (OZZ) has been developed and implemented. The underlying idea of OZZ is selective processing, or focus of attention. The binary input image is scanned intermittently and rather sparsely, but nevertheless all the necessary information needed to detect bars is extracted. Black pixels constitute a small fraction of the input drawing. Of these pixels, OZZ processes only a small fraction, resulting in both a dramatic reduction in both space and time compared to HT.

Design and Development of Kinect-Based Technology-Enhanced Teaching Classroom

This paper presents an innovative use of the Kinect camera in designing a cost effective technology-enhanced teaching classroom consisting of a multi-touch interactive whiteboard and a teaching station. The design principle of the system is based on the capability of Kinect to send a fixed speckle pattern towards a plane, track the reflected IR sources in real time, undertake the necessary processing and finally achieve an interactive multi-touch surface. The classroom can operate with either existing teaching applications or the customized Multi-touch Teaching Module. The Teaching Module allows instructors to manipulate teaching content such as animations, streaming video lectures, schematic diagrams and so on more naturally through supported hand gestures such as panning, rotating, zooming in and out, etc. When the classroom is operating with existing teaching applications, instructors can intuitively interact with teaching content using their fingers on the large projected display or on the table surface, instead of relying on a mouse and keyboard. Initial evaluation results of the technology-enhanced teaching classroom by lecturers show positive feedback over standard computers as it is much easier to operate. The cost-effective technology-enhanced classroom is able to provide similar features offered by commercially available interactive whiteboards or multi-touch teaching stations and could be adopted as an alternative in a budget restricted environment.

Batch Resizing Policies and Techniques for Fine-Grain Grid Tasks: The Nuts and Bolts

The overhead of processing fine-grain tasks on a grid induces the need for batch processing or task group deployment in order to minimise overall application turnaround time. When deciding the granularity of a batch, the processing requirements of each task should be considered as well as the utilisation constraints of the interconnecting network and the designated resources. However, the dynamic nature of a grid requires the batch size to be adaptable to the latest grid status. In this paper, we describe the policies and the specific techniques involved in the batch resizing process. We explain the nuts and bolts of these techniques in order to maximise the resulting benefits of batch processing. We conduct experiments to determine the nature of the policies and techniques in response to a real grid environment. The techniques are further investigated to highlight the important parameters for obtaining the appropriate task granularity for a grid resource.

Pthreads Performance Characteristics on Shared Cache CMP, Private Cache CMP and SMP

With the wide availability of chip multi-processing (CMP), software developers are now facing the task of effectively parallelizing their software code. Once they have identified the areas of parallelization, they will need to know the level of code granularity needed to ensure profitable execution. Furthermore, this problem multiplies itself with different hardware available. In this paper, we present a novel approach for fair comparison of the hardware configuration by simulation through configuring a pair of quad-core processors. The simulated configuration represents shared cache CMP, private cache CMP and symmetrical multiprocessor (SMP) environment. We then present a modified lmbench micro-benchmark suite to measure the cost of threading on these different hardware configurations. In our empirical studies, we observe that shared cache CMP exhibits better performance when the operating systems load balancer is highly active. However, the measurements also indicate that thread size is an important consideration where potential cache trashing can occur when sharing a cache between processing cores. Private cache CMP and SMP do not exhibit significant difference in our measurements. The techniques presented can be incorporated into integrated development environment, compilers and potentially even other run-time environments.

QoS-based Task Group Deployment on Grid by Learning the Performance Data

Overhead of executing fine-grain tasks on computational grids led to task group or batch deployment in which a batch is resized according to the characteristics of the tasks, designated resource, and the interconnecting network. An economic grid demands an application to be processed within the given budget and deadline, referred to as the quality of service (QoS) requirements. In this paper, we increase the task success rate in an economic grid by optimally mapping the tasks to the resources prior to the batch deployment. The task-resource mapping (Advance QoS Planning) is decided based on QoS requirement and by mining the historical performance data of the application tasks using a genetic algorithm. The mapping is then used to assist in creating the task groups. Practical experiments are conducted to validate the proposed method and suggestions are given to implement our method in a cloud environment as well as to process real-time tasks.