@ankurm

Ankur in CG

Implementing Midpoint Ellipse Algorithm in C++

Ellipses are fundamental shapes in computer graphics, widely used in various applications such as image processing, animation, and CAD systems. In this blog post, we'll explore how to draw an ellipse using the Midpoint Ellipse Algorithm in C++ with graphics.h. Introduction to Midpoint Ellipse Algorithm The Midpoint Ellipse Algorithm is an efficient way to generate an ellipse using only integer operations. It is based on the midpoint method, which determines the next pixel position by evaluating a decision parameter. This algorithm divides the ellipse into two regions: Region 1: The slope of the curve is less than 1. Region 2: The slope of the curve is greater than 1. Each region is processed separately to ensure a smooth curve. C++ Code Implementation Below is the C++ program that implements the Midpoint Ellipse Algorithm. It uses the graphics.h library, which is part of the Turbo C++ environment.

Ankur in CG

Implementing Flood Fill Algorithm in C++

The Flood Fill Algorithm fills a connected region on a raster display by replacing all pixels that share the same original colour as the seed pixel with a new fill colour. Unlike the Boundary Fill Algorithm — which stops at a specific boundary colour — Flood Fill continues spreading in all directions as long as the pixel matches the original seed colour. It is the underlying technique used by the “Paint Bucket” tool in image editors.

Ankur in CG

C++ Program to Implement DDA Line Drawing Algorithm

The Digital Differential Analyzer (DDA) algorithm is one of the simplest line-drawing algorithms in computer graphics. It is an incremental method that determines intermediate points between two given endpoints of a line. In this blog post, we will explore the DDA algorithm, understand its working, and implement it using C++. What is the DDA Algorithm? The DDA (Digital Differential Analyzer) algorithm is a rasterization algorithm used to draw lines on a pixel-based display. It works by calculating the intermediate points that form a straight line between two given points and plotting them sequentially. The algorithm uses floating-point arithmetic to incrementally determine the next pixel position. Steps of the DDA Algorithm: Calculate the change in x (dx) and y (dy) between the starting and ending points. Determine the number of steps required for the line. This is the greater value between dx and dy. Compute the increment values dx/steps and dy/steps to determine how much x and y should increase per step. Start from the initial point and iteratively plot the next points by adding the increment values. Stop when the endpoint is reached. C++ Implementation of DDA Algorithm Here is a simple C++ program to implement the DDA line drawing algorithm using the graphics.h library:

Ankur in CG

C++ Program to Implement Cohen Sutherland Algorithm

The Cohen-Sutherland Line Clipping Algorithm is one of the most widely used algorithms in computer graphics for clipping line segments against a rectangular viewport. It works by assigning a 4-bit region code to each endpoint of a line to quickly determine whether the line is fully inside the window, fully outside, or needs to be clipped. The algorithm avoids expensive intersection calculations whenever possible, making it very efficient for real-time rendering pipelines.

Ankur in CG

To Implement Character Generation by using Bitmap Method in C++

Character Generation by the Bitmap Method is a fundamental technique in computer graphics for rendering text or custom symbols on a raster display. A character is represented as a two-dimensional binary (or integer) grid — called a bitmap — where each cell in the grid corresponds to one pixel. A 1 (or any non-zero value) means the pixel should be drawn; a 0 means it should be left blank. This method is used in early video games, embedded displays, and any system that needs custom pixel-perfect fonts.

Ankur in Mix (C++ and Assembly)

Mix (C++ and Assembly) Program to Sort Numbers in Descending Order

This post demonstrates how to sort an array of integers using inline assembly in C++. We use basic comparison and swap logic in assembly embedded within a C++ program. #include<iostream.h> #include<conio.h> void main() { int a[5], x, y; int i, j; cout << "\n Enter 5 Numbers:"; for(i = 0; i < 5; i++) { cin >> a[i]; } //Sorting for(i = 0; i < 4; i++) { for(j = 0; j < 4; j++) { x = a[j]; y = a[j + 1]; asm { mov ax, x mov bx, y cmp ax, bx jge nxt mov cx, ax mov ax, bx mov bx, cx mov x, ax mov y, bx } nxt: a[j] = x; a[j + 1] = y; } } cout << "\n Sorted Array:"; for(i = 0; i < 5; i++) cout << a[i] << " "; getch(); }

Ankur in CG

Implementing Bresenham’s Circle Drawing Algorithm in C++

Bresenham's circle algorithm is an efficient way to draw a circle using only integer calculations. It eliminates the need for floating-point arithmetic and is widely used in computer graphics. Below is the implementation of Bresenham's circle drawing algorithm using C++ and the graphics.h library. This program takes user input for the circle's center and radius, then uses the algorithm to plot the circle.

Ankur in CG

Implementing Boundary Fill Algorithm in C++

The Boundary Fill Algorithm is a region-filling technique used in computer graphics to fill a connected area with a new colour. Starting from a seed pixel inside the shape, the algorithm recursively colours every neighbouring pixel as long as it does not match the defined boundary colour and has not already been coloured with the new fill colour. It supports 8-connected filling, meaning it spreads to all eight surrounding pixels — including diagonals.

Ankur in CG

Implementing Bresenham’s Line Algorithm in C++

Bresenham's Line Algorithm is one of the most fundamental algorithms in computer graphics. It determines the set of pixels that most closely approximate a straight line between two given endpoints on a raster display. The key advantage of Bresenham's algorithm over simpler approaches is that it uses only integer arithmetic — no floating-point multiplication or division — making it extremely fast for hardware and software rendering alike.

Ankur in CG

Implementing 2-D Transformation in C++

2-D Transformations are fundamental operations in computer graphics that change the position, size, or orientation of geometric objects on a 2-D plane. The three basic transformations are Translation (moving an object), Scaling (resizing an object), and Rotation (rotating an object about the origin). This C++ program implements all three transformations on a line segment entered by the user and renders the transformed result using the Turbo C++ graphics.h library.