47:"/_next/static/immutable/chunks/1kmido8zahgj5.js" 48:I[46757,["$2","$3","$4","$5","$10","$e","$47"],"default"] 49:T755,This C code implements Bresenham's Line Algorithm, a fundamental algorithm in computer graphics for drawing lines on a digital display. The program uses the `graphics.h` library, which is a legacy library primarily associated with DOS-based C compilers like Turbo C/C++. The core functionality resides in the `lineBres` function, which takes two points (`xa, ya` and `xb, yb`) as input and draws a line between them using white pixels. The algorithm's main advantage is that it uses only integer arithmetic, making it very efficient and fast compared to algorithms that rely on floating-point calculations (like DDA). The `lineBres` function first determines the absolute differences in x and y coordinates (`dx` and `dy`). It then divides the problem into two main cases based on the slope of the line: 1. **Slope magnitude <= 1 (i.e., `dx >= dy`)**: In this case, the line is "more horizontal." The algorithm iterates along the x-axis, incrementing `x` by 1 in each step. It then decides whether to keep `y` the same or increment/decrement `y` by 1, based on a decision parameter `p`. The `step` variable ensures `y` moves in the correct direction (up or down). 2. **Slope magnitude > 1 (i.e., `dx < dy`)**: Here, the line is "more vertical." The algorithm iterates along the y-axis, incrementing `y` by 1 in each step. It decides whether to keep `x` the same or increment/decrement `x` by 1, again using the decision parameter `p`. The `step` variable ensures `x` moves in the correct direction (left or right). The `main` function initializes the graphics environment using `initgraph`, then makes multiple calls to `lineBres` with different coordinate pairs. These calls collectively draw a specific shape, which appears to be an outline of a house with a window and a door. Finally, `getch()` waits for user input, and `closegraph()` shuts down the graphics system.4a:T850,Bresenham's Line Algorithm works by incrementally determining the next pixel to plot based on a decision parameter that minimizes the error between the true line and the plotted pixel. Here are the steps: 1. **Initialization**: * Read the two endpoints of the line: `(xa, ya)` and `(xb, yb)`. * Calculate the absolute differences: `dx = |xa - xb|` and `dy = |ya - yb|`. * Determine the starting pixel `(x, y)` and the ending coordinate (`xEnd` or `yEnd`) for iteration. This is done to ensure the line is drawn from left to right (for `dx >= dy`) or bottom to top (for `dx < dy`). * Calculate a `step` variable to determine the direction of change for the non-dominant axis (e.g., if `y` should increase or decrease). 2. **Case 1: Slope magnitude <= 1 (`dx >= dy`)**: * If `xa > xb`, swap `(xa, ya)` and `(xb, yb)` to always draw from left to right. Set `x = xa`, `y = ya`, `xEnd = xb`. Adjust `step` based on `ya` vs `yb`. * Initialize the decision parameter: `p = 2 * dy - dx`. * Plot the initial pixel `(x, y)`. * **Loop**: While `x < xEnd`: * Increment `x`. * If `p < 0` (the midpoint is below the line): * Update `p = p + 2 * dy`. (y remains the same) * Else (the midpoint is above or on the line): * Update `y = y + step`. * Update `p = p + 2 * (dy - dx)`. * Plot the new pixel `(x, y)`. 3. **Case 2: Slope magnitude > 1 (`dx < dy`)**: * If `ya > yb`, swap `(xa, ya)` and `(xb, yb)` to always draw from bottom to top. Set `y = ya`, `x = xa`, `yEnd = yb`. Adjust `step` based on `xa` vs `xb`. * Initialize the decision parameter: `p = 2 * dx - dy`. * Plot the initial pixel `(x, y)`. * **Loop**: While `y < yEnd`: * Increment `y`. * If `p < 0` (the midpoint is to the left of the line): * Update `p = p + 2 * dx`. (x remains the same) * Else (the midpoint is to the right of or on the line): * Update `x = x + step`. * Update `p = p + 2 * (dx - dy)`. * Plot the new pixel `(x, y)`.4b:Tdc7,This C code implements the Midpoint Ellipse Drawing Algorithm to render ellipses on a graphical display. It utilizes the `graphics.h` library, a common library for simple graphics programming in DOS-based C compilers like Turbo C/C++. The code is structured into three main parts: 1. **`plotPoints` function**: This helper function takes the center coordinates (`xc`, `yc`) and the current offset (`x`, `y`) from the center. It then draws four pixels symmetrically around the center: `(xc+x, yc+y)`, `(xc-x, yc+y)`, `(xc+x, yc-y)`, and `(xc-x, yc-y)`. This leverages the eight-way symmetry of an ellipse, but since the Midpoint algorithm only calculates points for one octant (specifically, one quadrant and then mirrors for the other three), this function simplifies plotting. For ellipses, it efficiently plots points in all four quadrants from calculations in just one. 2. **`drawEllipse` function**: This is the core of the algorithm. It takes the center coordinates (`xc`, `yc`) and the horizontal (`rx`) and vertical (`ry`) radii as input. * It first pre-calculates squared radii (`rx2`, `ry2`) and doubled squared radii (`twoRx2`, `twoRy2`) to optimize calculations, avoiding repeated multiplications inside the loops. * The algorithm starts drawing from the top-most point of the ellipse `(0, ry)` relative to the center. * It divides the ellipse into two regions based on the slope of the curve. * **Region 1**: This region covers the part of the ellipse where the absolute value of the slope `|dy/dx|` is less than 1. It starts from `(0, ry)` and moves towards `(rx, ry/sqrt(2))`. In this region, `x` is incremented in each step, and `y` may or may not be decremented based on a decision parameter `p`. * **Region 2**: This region covers the part where `|dy/dx|` is greater than 1. It starts where Region 1 left off and continues until `(rx, 0)`. In this region, `y` is decremented in each step, and `x` may or may not be incremented. * In both regions, a decision parameter `p` is used. This parameter determines which of two potential next pixels is closer to the true ellipse curve. Based on `p`'s sign, `y` (in Region 1) or `x` (in Region 2) is updated, and `p` itself is incrementally updated for the next iteration. This avoids costly floating-point calculations at each step. * For each calculated `(x, y)` pair, `plotPoints` is called to draw the corresponding symmetric pixels. 3. **`main` function**: This is the entry point of the program. * It initializes the graphics mode using `initgraph(&gd, &gm, "C:\\TC\\BGI")`. `DETECT` tells the system to automatically detect the graphics driver, `gm` stores the detected mode, and `"C:\\TC\\BGI"` specifies the path to the BGI (Borland Graphics Interface) driver files. * It then calls `drawEllipse` multiple times with different parameters to create a "flower" pattern. It also uses the `line` function from `graphics.h` to draw a stem and some petal/leaf-like structures. * `getch()` pauses the program execution until a key is pressed, allowing the user to view the drawing. * `closegraph()` de-initializes the graphics system and returns to text mode. In essence, the code draws an ellipse by iteratively calculating pixel coordinates in one quadrant using integer arithmetic and then mirroring those points to complete the entire ellipse, all within a graphical environment. The `main` function then uses this ellipse drawing capability to compose a simple artistic rendering.4c:Taa3,The Midpoint Ellipse Drawing Algorithm is used, which is an incremental algorithm based on the implicit equation of an ellipse: $F(x,y) = ry^2x^2 + rx^2y^2 - rx^2ry^2 = 0$. The algorithm steps are: 1. **Initialization**: * Get the center coordinates `(xc, yc)` and radii `rx`, `ry`. * Calculate `rx2 = rx * rx`, `ry2 = ry * ry`. * Calculate `twoRx2 = 2 * rx2`, `twoRy2 = 2 * ry2` for efficiency. * Set the initial point `(x, y)` to `(0, ry)` (relative to the ellipse center). * Calculate `px = 0` and `py = twoRx2 * y`. These represent `2 * ry^2 * x` and `2 * rx^2 * y` respectively, which are used in the decision parameter updates. 2. **Region 1 (Slope `|dy/dx| < 1`)**: * This region starts at `(0, ry)` and continues as long as `px < py` (which implies `2 * ry^2 * x < 2 * rx^2 * y`, or `ry^2 * x < rx^2 * y`). * **Initial Decision Parameter `p1`**: `p = ry2 - (rx2 * ry) + (0.25 * rx2) + 0.5;` (This is often approximated to `ry2 - rx2 * ry + rx2 / 4` for integer arithmetic.) * **Loop for Region 1**: * Plot the current `(x, y)` and its symmetric points using `plotPoints(xc, yc, x, y)`. * Increment `x` (`x++`). * Update `px`: `px += twoRy2` (equivalent to `px = 2 * ry^2 * (x+1)`). * **Check `p`**: * If `p < 0` (midpoint is inside the ellipse, choose `(x+1, y)`): `p += ry2 + px;` * Else (midpoint is outside or on the ellipse, choose `(x+1, y-1)`): Decrement `y` (`y--`). Update `py`: `py -= twoRx2` (equivalent to `py = 2 * rx^2 * (y-1)`). `p += ry2 + px - py;` 3. **Region 2 (Slope `|dy/dx| > 1`)**: * This region starts where Region 1 left off and continues as long as `y > 0`. * **Initial Decision Parameter `p2`**: `p = (long)(ry2 * (x + 0.5) * (x + 0.5) + rx2 * (y - 1) * (y - 1) - rx2 * ry2 + 0.5);` (This recalculates `p` for the new starting point of Region 2, effectively `F(x+0.5, y-1)` with some adjustments.) * **Loop for Region 2**: * Plot the current `(x, y)` and its symmetric points using `plotPoints(xc, yc, x, y)`. * Decrement `y` (`y--`). * Update `py`: `py -= twoRx2`. * **Check `p`**: * If `p > 0` (midpoint is outside the ellipse, choose `(x, y-1)`): `p += rx2 - py;` * Else (midpoint is inside or on the ellipse, choose `(x+1, y-1)`): Increment `x` (`x++`). Update `px`: `px += twoRy2`. `p += rx2 - py + px;` 4. **Termination**: The algorithm terminates when `y` becomes 0 in Region 2, meaning it has reached `(rx, 0)`.4d:T1828,This C code implements the Midpoint Ellipse Drawing Algorithm, a fundamental technique in computer graphics for rendering ellipses efficiently. The program uses the BGI (Borland Graphics Interface) library, a common choice for graphics programming in older C/C++ environments, to draw shapes on a graphical screen. The core idea behind the Midpoint Ellipse Algorithm is to draw an ellipse by choosing the next pixel based on a decision parameter, which helps determine whether to move horizontally, vertically, or diagonally to best approximate the ellipse curve. This algorithm leverages the symmetry of an ellipse to reduce the number of calculations needed: it only computes points for one octant (or quadrant, depending on how you view the regions) and then uses `plotPoints` to reflect these points across the center to draw the full ellipse. Let's break down the code: 1. **`main()` function**: * This is the entry point of the program. * `int gd = DETECT, gm;` declares variables for graphics driver and mode. `DETECT` automatically detects the graphics hardware. * `initgraph(&gd, &gm, "C:\\TC\\BGI");` initializes the graphics system. It tells the program to look for the BGI driver files in the specified path ("C:\\TC\\BGI"). If successful, it switches the display to graphics mode. * `drawEllipse(324,239,50,50);` calls the `drawEllipse` function to draw a circle (an ellipse with equal radii) centered at (324, 239) with a radius of 50 pixels. * `drawEllipse(324,239,100,50);` calls `drawEllipse` again to draw a wider ellipse, also centered at (324, 239), with a horizontal radius (rx) of 100 and a vertical radius (ry) of 50. * `getch();` waits for the user to press any key before proceeding. This keeps the graphics window open so you can see the output. * `closegraph();` unloads the graphics driver and switches the display back to text mode. * `return 0;` indicates successful program execution. 2. **`plotPoints(int xc, int yc, int x, int y)` function**: * This helper function takes the center coordinates (`xc`, `yc`) and a relative offset `(x, y)` from the origin (0,0) of the current octant. * It then plots four symmetric points around the center `(xc, yc)`: * `(xc + x, yc + y)`: The point in the first quadrant. * `(xc - x, yc + y)`: Reflection across the Y-axis. * `(xc + x, yc - y)`: Reflection across the X-axis. * `(xc - x, yc - y)`: Reflection across both X and Y axes. * `putpixel(x_coord, y_coord, WHITE);` draws a single pixel at the specified coordinates in white color. This effectively draws portions of the ellipse in all four quadrants simultaneously. 3. **`drawEllipse(int xc, int yc, int rx, int ry)` function**: * This is the core implementation of the Midpoint Ellipse Algorithm. * It takes the center coordinates (`xc`, `yc`) and the horizontal (`rx`) and vertical (`ry`) radii. * **Variable Initialization**: * `rx2 = (long)rx * rx;` and `ry2 = (long)ry * ry;` pre-calculate the squares of the radii, cast to `long` to prevent overflow for larger radii. * `twoRx2 = 2 * rx2;` and `twoRy2 = 2 * ry2;` pre-calculate `2*rx^2` and `2*ry^2` for efficiency, as these terms are used repeatedly in the decision parameter updates. * `x = 0; y = ry;` sets the starting point for drawing in the first region, which is `(0, ry)` (the topmost point of the ellipse). * `px = 0; py = twoRx2 * y;` initializes `px` and `py`, which represent `2*ry^2*x` and `2*rx^2*y` respectively. These values are crucial for determining the slope condition to switch between regions. * **Region 1 (Top-Right Octant/Quadrant portion)**: * This region starts from `(0, ry)` and continues until the slope of the ellipse becomes -1 (i.e., `px < py` condition). * `p = (long)(ry2 - (rx2 * ry) + (0.25 * rx2) + 0.5);` initializes the decision parameter `p`. This initial value is derived from the midpoint equation for the ellipse at the starting point. The `0.25` and `0.5` terms are used for midpoint evaluation. * `while (px < py)`: The loop continues as long as `2*ry^2*x < 2*rx^2*y`, which implies that the absolute value of the slope `dy/dx` is less than 1. * `plotPoints(xc, yc, x, y);` draws the current point and its symmetric counterparts. * `x++; px += twoRy2;` increments `x` and updates `px` (which is `2*ry^2*x`). * `if (p < 0)`: If `p` is negative, the midpoint is inside the ellipse, so the East (E) pixel is chosen. `p` is updated by adding `ry2 + px`. * `else`: If `p` is non-negative, the midpoint is outside or on the ellipse, so the South-East (SE) pixel is chosen. `y--` decrements `y`, `py -= twoRx2` updates `py`, and `p` is updated by adding `ry2 + px - py`. * **Region 2 (Bottom-Right Octant/Quadrant portion)**: * This region takes over from where Region 1 left off, continuing until `y` reaches 0 (the rightmost point of the ellipse). In this region, the absolute value of the slope `dy/dx` is greater than 1. * `p = (long)(ry2 * (x + 0.5) * (x + 0.5) + rx2 * (y - 1) * (y - 1) - rx2 * ry2 + 0.5);` re-initializes the decision parameter `p` for Region 2. This formula uses the *last* `(x, y)` from Region 1 to calculate the midpoint for the next pixel choice. * `while (y > 0)`: The loop continues as long as `y` is greater than 0. * `plotPoints(xc, yc, x, y);` draws the current point and its symmetric counterparts. * `y--; py -= twoRx2;` decrements `y` and updates `py` (which is `2*rx^2*y`). * `if (p > 0)`: If `p` is positive, the midpoint is outside the ellipse, so the South (S) pixel is chosen. `p` is updated by adding `rx2 - py`. * `else`: If `p` is non-positive, the midpoint is inside or on the ellipse, so the South-East (SE) pixel is chosen. `x++` increments `x`, `px += twoRy2` updates `px`, and `p` is updated by adding `rx2 - py + px`. This two-region approach ensures that the algorithm always takes steps in the direction that best approximates the ellipse's curve, minimizing visual jaggedness. ---4e:T1535,This C code implements the Midpoint Ellipse Drawing Algorithm using the Borland Graphics Interface (BGI), a common graphics library for C/C++ in older DOS-based environments. The goal is to draw smooth ellipses on a graphical screen by calculating points along the ellipse's arc and plotting them. Here's a step-by-step breakdown: 1. **Includes**: * `graphics.h`: This header file provides functions for graphics operations like initializing the graphics mode, drawing pixels (`putpixel`), and closing the graphics screen. * `conio.h`: This header provides console input/output functions, specifically `getch()` which is used here to pause the program until a key is pressed. * `stdio.h`: This is the standard input/output library, though it's not strictly used in this particular code snippet for I/O, it's a common include. 2. **`plotPoints(int xc, int yc, int x, int y)` Function**: * This helper function takes the center coordinates of the ellipse (`xc`, `yc`) and a point `(x, y)` relative to the center. * It leverages the eight-way symmetry of an ellipse. For every point `(x, y)` calculated in the first quadrant, there are four corresponding symmetric points in all four quadrants relative to the center `(xc, yc)`. * It uses `putpixel(x_coord, y_coord, WHITE)` to draw these four pixels in white color. The four points are `(xc+x, yc+y)`, `(xc-x, yc+y)`, `(xc+x, yc-y)`, and `(xc-x, yc-y)`. 3. **`drawEllipse(int xc, int yc, int rx, int ry)` Function**: * This is the core function that implements the Midpoint Ellipse Algorithm. * It takes the center coordinates (`xc`, `yc`) and the major and minor radii (`rx`, `ry`). * **Initialization**: It calculates `rx2 = rx * rx` and `ry2 = ry * ry` (squared radii) and `twoRx2 = 2 * rx2`, `twoRy2 = 2 * ry2`. These pre-calculations optimize the loops by avoiding repeated multiplications. `x` and `y` are initialized to `0` and `ry` respectively, starting at the topmost point of the ellipse `(0, ry)` relative to its center. `px` and `py` are also initialized; these represent `2 * ry^2 * x` and `2 * rx^2 * y` respectively, which are used in the decision parameter updates. * **Region 1**: This region covers the part of the ellipse where the absolute value of the slope `|dy/dx|` is less than or equal to 1. It starts from `(0, ry)` and goes until `px >= py`. * It uses a decision parameter `p` to determine which pixel to choose next: either `(x+1, y)` or `(x+1, y-1)`. * The initial `p` is set based on the midpoint concept. * Inside the `while` loop: * `plotPoints` is called to draw the current `(x, y)` point and its symmetric counterparts. * `x` is incremented. * `px` is updated (`px += twoRy2`). * If `p < 0`, the midpoint is inside the ellipse, so the next point chosen is `(x+1, y)`. `p` is updated accordingly. * If `p >= 0`, the midpoint is outside or on the ellipse, so the next point chosen is `(x+1, y-1)`. `y` is decremented, `py` is updated, and `p` is updated. * **Region 2**: This region covers the part of the ellipse where the absolute value of the slope `|dy/dx|` is greater than 1. It starts from where Region 1 left off and goes until `y` becomes 0. * The decision parameter `p` is re-initialized for this region using the last `(x, y)` point from Region 1. * Inside the `while` loop: * `plotPoints` is called for the current `(x, y)` point. * `y` is decremented. * `py` is updated (`py -= twoRx2`). * If `p > 0`, the midpoint is outside the ellipse, so the next point chosen is `(x, y-1)`. `p` is updated. * If `p <= 0`, the midpoint is inside or on the ellipse, so the next point chosen is `(x+1, y-1)`. `x` is incremented, `px` is updated, and `p` is updated. * The loop continues until `y` reaches 0, completing the quarter ellipse segment. 4. **`main()` Function**: * `int gd = DETECT, gm;`: `gd` (graphics driver) is set to `DETECT` to auto-detect the graphics hardware, and `gm` (graphics mode) will be set by `initgraph`. * `initgraph(&gd, &gm, "C:\\TC\\BGI");`: This function initializes the graphics system. It loads the appropriate graphics driver (e.g., EGA, VGA) from the specified path (`C:\TC\BGI`) and sets the system to graphics mode. * `drawEllipse(162,239,70,100);`: Calls `drawEllipse` to draw an ellipse centered at `(162, 239)` with `rx=70` and `ry=100`. This will be a taller, vertically oriented ellipse. * `drawEllipse(486,239,100,70);`: Calls `drawEllipse` again to draw another ellipse centered at `(486, 239)` with `rx=100` and `ry=70`. This will be a wider, horizontally oriented ellipse. * `getch();`: Pauses the program execution until a key is pressed, allowing the user to view the drawn ellipses. * `closegraph();`: De-initializes the graphics system and returns the screen to text mode. * `return 0;`: Indicates successful program execution. In essence, the code calculates one segment of an ellipse (from `(0, ry)` to `(rx, 0)` in the first quadrant), and then uses symmetry to draw the other seven segments, resulting in a complete ellipse. It uses integer arithmetic and decision parameters for efficiency, avoiding floating-point calculations within the main loops as much as possible. ---4f:Ta26,The code implements the Midpoint Ellipse Drawing Algorithm, which is an incremental scan-conversion algorithm. It works by determining the next pixel to plot based on a decision parameter (midpoint criterion). Here's the algorithm in steps: 1. **Initialize Graphics**: Set up the graphics environment using `initgraph()`. 2. **Define Ellipse Parameters**: Get the center coordinates `(xc, yc)` and the semi-major and semi-minor axes `rx` and `ry`. 3. **Pre-calculate Constants**: * `rx2 = rx * rx` * `ry2 = ry * ry` * `twoRx2 = 2 * rx2` * `twoRy2 = 2 * ry2` 4. **Initialize Starting Point and Parameters for Region 1**: * Start at `(x, y) = (0, ry)`. * Initialize `px = 0` and `py = twoRx2 * y`. * Calculate the initial decision parameter for Region 1: `p = ry2 - (rx2 * ry) + (0.25 * rx2)`. (The `+ 0.5` in the code is for rounding in floating point calculations, before casting to `long`). 5. **Region 1 Loop (Slope `|dy/dx| <= 1`)**: * Loop `while (px < py)`: * Plot the current `(x, y)` point and its symmetric counterparts using `plotPoints(xc, yc, x, y)`. * Increment `x`: `x++`. * Update `px`: `px += twoRy2`. * **Decision**: * If `p < 0` (midpoint is inside the ellipse): * `p += ry2 + px`. * Else (midpoint is outside or on the ellipse): * Decrement `y`: `y--`. * Update `py`: `py -= twoRx2`. * `p += ry2 + px - py`. 6. **Initialize Starting Point and Parameters for Region 2**: * The starting point for Region 2 is the last `(x, y)` calculated in Region 1. * Calculate the initial decision parameter for Region 2: `p = ry2 * (x + 0.5) * (x + 0.5) + rx2 * (y - 1) * (y - 1) - rx2 * ry2`. (The `+ 0.5` in the code is for rounding in floating point calculations, before casting to `long`). 7. **Region 2 Loop (Slope `|dy/dx| > 1`)**: * Loop `while (y > 0)`: * Plot the current `(x, y)` point and its symmetric counterparts using `plotPoints(xc, yc, x, y)`. * Decrement `y`: `y--`. * Update `py`: `py -= twoRx2`. * **Decision**: * If `p > 0` (midpoint is outside the ellipse): * `p += rx2 - py`. * Else (midpoint is inside or on the ellipse): * Increment `x`: `x++`. * Update `px`: `px += twoRy2`. * `p += rx2 - py + px`. 8. **Clean Up Graphics**: Pause for user input (`getch()`) and then close the graphics mode (`closegraph()`). ---50:T64e,This C code implements the Digital Differential Analyzer (DDA) algorithm, a fundamental line-drawing algorithm in computer graphics, to draw a simple face-like figure on the screen. It utilizes the `graphics.h` library, which is a legacy library primarily used with DOS-based compilers like Turbo C/C++. The core logic resides in the `lineDDA` function. This function takes the starting coordinates (`xa`, `ya`) and ending coordinates (`xb`, `yb`) of a line segment. It calculates the difference in x (`dx`) and y (`dy`) coordinates. To draw the line, it determines which axis (x or y) has the larger absolute difference. This larger difference dictates the number of "steps" needed to draw the line. It then calculates small increments (`xInc`, `yInc`) for x and y for each step. Starting from the initial point, it iteratively adds these increments to the current x and y coordinates, rounding them to the nearest integer before plotting each pixel using `putpixel`. This process effectively "walks" along the line, plotting individual pixels to form a continuous segment. The `main` function initializes the graphics mode using `initgraph`, which sets up the graphical display. It then makes multiple calls to the `lineDDA` function with different coordinate pairs. Each call draws a specific line segment. Together, these segments form a simple outline of a face: an outer square for the head, two smaller squares for eyes, a triangular nose, a rectangular mouth, and two triangular ears. Finally, `getch()` waits for a key press before `closegraph()` shuts down the graphics system and returns to text mode.51:T664,The Digital Differential Analyzer (DDA) algorithm for line drawing, as implemented in this code, follows these steps: 1. **Input:** Obtain the starting coordinates `(xa, ya)` and ending coordinates `(xb, yb)` of the line. 2. **Calculate Differences:** Compute the differences in x and y coordinates: * `dx = xb - xa` * `dy = yb - ya` 3. **Determine Steps:** Find the number of steps required to draw the line. This is determined by the larger absolute difference between `dx` and `dy`. * If `|dx| > |dy|`, then `steps = |dx|`. * Else, `steps = |dy|`. * This ensures that the line is sampled at least once per unit along the dominant axis, preventing gaps. 4. **Calculate Increments:** Determine the fractional increments for x and y for each step. * `xInc = dx / (float) steps` * `yInc = dy / (float) steps` * Casting `steps` to `float` is crucial to ensure floating-point division. 5. **Initialize Current Position:** Set the current plotting position to the starting point: * `x = xa` * `y = ya` 6. **Plot Initial Pixel:** Plot the starting pixel by rounding the current `x` and `y` coordinates to the nearest integer. * `putpixel(ROUND(x), ROUND(y), WHITE)` 7. **Iterate and Plot:** Loop `steps` times to draw the rest of the line: * In each iteration `k` (from `0` to `steps - 1`): * Update the current x and y coordinates: * `x = x + xInc` * `y = y + yInc` * Plot the new pixel by rounding the updated `x` and `y` coordinates to the nearest integer. * `putpixel(ROUND(x), ROUND(y), WHITE)`52:T1021,This C program demonstrates the **Digital Differential Analyzer (DDA)** algorithm, a fundamental method for drawing lines on a raster graphics display. The core idea behind DDA is to calculate points along a line by incrementally adding small fractional values to the current x and y coordinates, then rounding these to integer pixel positions. Here's how the code works step-by-step: 1. **Includes and Macro**: * `#include`: This header provides functions for graphics operations, such as initializing the graphics mode, drawing pixels, and closing the graphics window. It's part of the Borland Graphics Interface (BGI). * `#include`: This header provides console input/output functions, specifically `getch()` which is used here to pause the program until a key is pressed. * `#define ROUND(a) ((int)(a+0.5))`: This macro is defined to perform rounding to the nearest integer. For any floating-point number `a`, adding `0.5` to it and then type-casting to `int` effectively rounds it. For example, `3.2 + 0.5 = 3.7 -> (int)3.7 = 3`, and `3.7 + 0.5 = 4.2 -> (int)4.2 = 4`. 2. **`lineDDA` Function**: * This function takes four integer arguments: `(xa, ya)` representing the starting coordinates of the line and `(xb, yb)` representing the ending coordinates. * `int dx = xb - xa;` and `int dy = yb - ya;`: It calculates the total change in x (`dx`) and y (`dy`) required to draw the line. * `int steps;`: This variable will store the number of pixels to be drawn along the line. * `if(abs(dx) > abs(dy)) steps = abs(dx); else steps = abs(dy);`: The algorithm determines the number of steps based on the larger absolute difference between `dx` and `dy`. This ensures that the line is drawn smoothly, incrementing by at least one pixel along the major axis (the one with the larger change). * `float xInc = dx / (float) steps;` and `float yInc = dy / (float) steps;`: These calculate the incremental values for x and y for each step. For instance, if `dx` is 100 and `steps` is 100, `xInc` will be 1. If `dy` is 50 and `steps` is 100, `yInc` will be 0.5. This means for every step, x will increase by 1 and y will increase by 0.5. * `float x = xa, y = ya;`: Initializes the current x and y coordinates to the starting point. These are `float` to allow for fractional increments. * `putpixel(ROUND(x), ROUND(y), WHITE);`: The first pixel (the starting point) is drawn using the `putpixel` function, rounding its coordinates to the nearest integer. * `for(k=0; k |dy|`, the number of steps (`steps`) is set to `|dx|`. * Otherwise, `steps` is set to `|dy|`. This ensures that the line is sampled at a rate that covers all pixels along the longer axis. 4. **Calculate Increments**: * Calculate the x-increment per step: `xInc = dx / (float)steps`. * Calculate the y-increment per step: `yInc = dy / (float)steps`. 5. **Initialize Current Position**: Set the current floating-point coordinates `(x, y)` to the starting point `(xa, ya)`. 6. **Draw Initial Pixel**: Draw the first pixel at `(ROUND(x), ROUND(y))` in `WHITE` color. 7. **Iterate and Draw**: * Loop `steps` times (from `k=0` to `k < steps`). * In each iteration: * Update `x` by adding `xInc`: `x = x + xInc`. * Update `y` by adding `yInc`: `y = y + yInc`. * Draw a pixel at the rounded current coordinates: `putpixel(ROUND(x), ROUND(y), WHITE)`. 8. **Graphics Cleanup**: After drawing, wait for user input (`getch()`) and then close the graphics mode (`closegraph()`). ---54:T11b8,This C code implements the **Midpoint Circle Algorithm** to draw circles on a graphical display using the Borland Graphics Interface (BGI). The BGI is a legacy graphics library commonly used with compilers like Turbo C/C++. Let's break down the code: 1. **`#include` directives**: * `graphics.h`: This header file provides access to the BGI functions (like `initgraph`, `putpixel`, `circle`, `rectangle`, `line`, `getch`, `closegraph`). * `conio.h`: This header is typically used for console input/output, specifically `getch()` in this case, which waits for a key press. * `stdio.h`: Standard input/output library, though not strictly necessary for this specific graphics code, it's a common inclusion. 2. **`circlePlotPoints(int xc, int yc, int x, int y)` function**: * This helper function takes the center coordinates (`xc`, `yc`) and a point `(x, y)` from the first octant (0 to 45 degrees) of the circle. * Due to the 8-way symmetry of a circle, if we know one point `(x, y)` in the first octant, we can derive seven other symmetric points. * `putpixel(x_coordinate, y_coordinate, color)` is a BGI function that draws a single pixel at the specified coordinates with the given color (here, `WHITE`). * This function plots all eight symmetric points for a given `(x, y)` pair, effectively drawing a segment of the circle in all octants simultaneously. 3. **`circleMidpoint(int xc, int yc, int r)` function**: * This is the core function that implements the Midpoint Circle Algorithm. * `xc`, `yc` are the center coordinates of the circle, and `r` is its radius. * It initializes `x = 0` and `y = r`. These are the starting coordinates, representing the topmost point of the circle (or rightmost, depending on perspective, but `x=0, y=r` is on the y-axis, 90 degrees). * `p = 1 - r`: This is the initial **decision parameter**. The decision parameter helps determine which pixel to choose in the next step (either `(x+1, y)` or `(x+1, y-1)`) by checking if the midpoint between these two candidate pixels is inside or outside the circle. * `circlePlotPoints(xc, yc, x, y)`: Plots the initial point and its 7 symmetric counterparts. * `while (x < y)`: The loop continues as long as `x` is less than `y`. This condition ensures that we only calculate points for the first octant (from 0 to 45 degrees). Once `x` becomes equal to or greater than `y`, we have covered the first 45 degrees, and the rest of the circle can be generated by symmetry. * `x++`: In each iteration, `x` is incremented. * **Decision Logic (`if (p < 0)` / `else`)**: * If `p < 0`, the midpoint is inside the circle or on its boundary. The next pixel chosen is `(x+1, y)`. The decision parameter `p` is updated by `p += 2 * x + 1`. * If `p >= 0`, the midpoint is outside the circle. The next pixel chosen is `(x+1, y-1)`. In this case, `y` is decremented (`y--`), and `p` is updated by `p += 2 * (x - y) + 1`. * `circlePlotPoints(xc, yc, x, y)`: After deciding the next `(x, y)` coordinate, all eight symmetric points are plotted. 4. **`main()` function**: * `int gd = DETECT, gm;`: `gd` (graphics driver) is set to `DETECT` to auto-detect the graphics hardware, and `gm` (graphics mode) will be determined by `initgraph`. * `initgraph(&gd, &gm, "C:\\TC\\BGI");`: This crucial BGI function initializes the graphics system. It takes pointers to `gd` and `gm` and the path to the BGI driver files (e.g., `EGAVGA.BGI`). The path `C:\\TC\\BGI` is a common location for these files in a Turbo C++ installation. * The code then makes several calls to `circleMidpoint` to draw circles at the screen corners and other locations. * It also uses standard BGI functions like `rectangle(left, top, right, bottom)` and `line(x1, y1, x2, y2)` to draw rectangles and lines, creating a composite graphic. Notice the drawing of a "sun" with rays using a circle and multiple lines. * `getch()`: This function from `conio.h` waits for the user to press any key before proceeding. This keeps the graphics window open until the user is ready to close it. * `closegraph()`: This BGI function unloads the graphics driver and restores the screen to its original text mode. * `return 0;`: Indicates successful program execution. In essence, this program demonstrates how to draw circles efficiently using an integer-only algorithm, then combines these circles with other basic shapes to create a simple graphical output.55:T7b5,The algorithm used is the **Midpoint Circle Algorithm** (also known as Bresenham's Circle Algorithm variation). It leverages 8-way symmetry to draw circles efficiently using only integer arithmetic. 1. **Initialization**: * Set the center coordinates of the circle as `(xc, yc)` and the radius as `r`. * Start with the initial point `(x, y)` for the first octant (0 to 45 degrees) as `x = 0` and `y = r`. * Calculate the initial decision parameter `p = 1 - r`. 2. **Plot Initial Points**: * Plot the initial `(x, y)` point and its seven symmetric points around the center `(xc, yc)` using the `circlePlotPoints` helper function. The symmetric points are: * `(xc + x, yc + y)` * `(xc - x, yc + y)` * `(xc + x, yc - y)` * `(xc - x, yc - y)` * `(xc + y, yc + x)` * `(xc - y, yc + x)` * `(xc + y, yc - x)` * `(xc - y, yc - x)` 3. **Iteration (Loop for First Octant)**: * Continue iterating as long as `x < y`. This ensures points are generated only for the first octant (from 0 to 45 degrees). * **Increment `x`**: In each step, increment `x` by 1 (`x++`). * **Decision**: * **If `p < 0`**: The midpoint between the candidate pixels `(x+1, y)` and `(x+1, y-1)` is inside the circle. Choose `(x+1, y)` as the next pixel. Update the decision parameter: `p = p + 2 * x + 1`. * **Else (`p >= 0`)**: The midpoint is outside or on the circle. Choose `(x+1, y-1)` as the next pixel. Decrement `y` by 1 (`y--`). Update the decision parameter: `p = p + 2 * (x - y) + 1`. * **Plot Points**: After determining the new `(x, y)` coordinates, plot this point and its seven symmetric counterparts using `circlePlotPoints`. 4. **Termination**: * The loop terminates when `x` becomes equal to or greater than `y`, indicating that all necessary points for the first octant have been generated. The entire circle is drawn by symmetry.56:Tc3a,This C code implements the Midpoint Circle Algorithm to draw a circle on a graphics screen. It uses the Borland Graphics Interface (BGI) library, a traditional graphics library for C/C++ compilers like Turbo C/C++. Let's break down its functionality step by step: 1. **Setting up Graphics**: The `main` function first initializes the graphics mode. It attempts to detect the best graphics driver and then loads it, typically requiring BGI driver files (like `EGAVGA.BGI`) to be present in the specified directory, "C:\\TC\\BGI" in this case. If successful, it switches the display from text mode to graphics mode. 2. **Drawing a Circle (Midpoint Algorithm)**: The `circleMidpoint` function is the heart of the program. It takes the center coordinates (`xc`, `yc`) and the radius (`r`) of the circle as input. * It starts by considering a point on the top of the circle, specifically `(0, r)` relative to the circle's center. * Then, it iteratively calculates the next point along the circle's path, specifically focusing on the first octant (the 45-degree segment from 0 to 45 degrees, starting from the top-right). * For each step, it decides whether the next pixel should be directly to the right or diagonally down-right, based on a "decision parameter" (`p`). This parameter essentially tells us whether the midpoint between these two candidate pixels is inside or outside the ideal circle path. * If the midpoint is inside, it chooses the pixel directly to the right. If it's outside or on the circle, it chooses the pixel diagonally down-right. * This process continues until `x` becomes greater than `y`, meaning it has covered the first octant. 3. **Plotting Points (Symmetry)**: The `circlePlotPoints` function is crucial for efficiency. Since a circle is highly symmetrical, if we calculate one point in the first octant (e.g., `(x, y)` relative to the center), we can automatically derive 7 other points by simply changing the signs and swapping `x` and `y` coordinates. * For example, if `(x, y)` is a point in the first octant, then `(-x, y)`, `(x, -y)`, `(-x, -y)` are points in other quadrants. * Similarly, `(y, x)`, `(-y, x)`, `(y, -x)`, `(-y, -x)` are points obtained by swapping x and y, which correspond to points in the other four octants. * This function takes the current `(x, y)` coordinates (relative to the center) and plots all eight symmetric points on the screen using the `putpixel` function, which draws a single pixel at a specified coordinate with a given color (WHITE in this case). 4. **Display and Exit**: After the `circleMidpoint` function completes drawing the circle, `main` calls `getch()` to pause the program and wait for the user to press any key. This allows the user to see the drawn circle. Finally, `closegraph()` is called to close the graphics mode and return the screen to its original text mode before the program exits. In essence, the code calculates just one-eighth of the circle's pixels and then uses symmetry to quickly draw the entire circle, making it a very efficient way to render circles in computer graphics.57:T490,The code implements the Midpoint Circle Algorithm, which is an efficient method for rasterizing circles. Here are the steps: 1. **Initialization**: * Input: Center coordinates `(xc, yc)` and radius `r`. * Set initial point `x = 0`, `y = r`. * Initialize the decision parameter `p = 1 - r`. 2. **Plot Initial Points**: * Plot the 8 symmetric points for the initial `(x, y)` relative to the center `(xc, yc)`. 3. **Iterative Calculation (First Octant)**: * Loop while `x < y`: * Increment `x` by 1. * **Decision**: * If `p < 0` (midpoint is inside the circle): The next pixel is `(x, y)`. Update `p = p + 2 * x + 1`. * Else (`p >= 0`, midpoint is outside or on the circle): The next pixel is `(x, y-1)`. Decrement `y` by 1. Update `p = p + 2 * (x - y) + 1`. * **Plot Points**: Plot the 8 symmetric points for the new `(x, y)` relative to the center `(xc, yc)`. 4. **Termination**: * The loop terminates when `x` becomes equal to or greater than `y`, indicating that the 45-degree line has been reached, and all necessary points in the first octant have been generated.30:["$","$L48",null,{"view":"lab-internal","props":{"classCode":"ec2428","subjectCode":"ec-cg","initialLabInfo":{"lab":{"id":"6d6f8211-1595-4554-800f-37501be64ff6","class_code":"EC2428,YI9I9UW7","name":"Electronics and Computer Engineering","description":"","created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"Agnel Institute of Engineering and Management","is_public":true,"members":null,"code":"EC2428","isOwner":false,"canContribute":false},"isOwner":false,"isMember":false},"initialSubjects":[{"id":"81afbbfc-f21d-457f-a398-4ef83be99228","class_code":"EC-IAI","parent_class_code":"EC2428,YI9I9UW7","code_lang":null,"name":"IAI","description":"Introduction to Artificial Intelligence Lab","semester":4,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-03-04T10:44:39.852045+00:00","updated_at":"2026-07-14T16:44:28.128+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"8e9c8fb0-c6bd-418c-aecb-b37587e17541","class_code":"EC-MCI","parent_class_code":"EC2428,YI9I9UW7","code_lang":null,"name":"MCI","description":"Microcontroller and Interfacing Lab","semester":4,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-03-06T09:17:38.733755+00:00","updated_at":"2026-07-14T16:44:28.129+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"94dd630a-8e3a-41ec-822d-36ae0981b8fc","class_code":"EC-JAVA","parent_class_code":"EC2428,YI9I9UW7","code_lang":null,"name":"Java OOP","description":"Object oriented Programming using JAVA Lab","semester":4,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-01-27T06:12:49.041709+00:00","updated_at":"2026-07-14T16:44:28.126+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"53e89393-458d-4ec8-80bc-ec74a7a7c928","class_code":"EC-DBMS","parent_class_code":"EC2428,YI9I9UW7","code_lang":"SQL","name":"DBMS","description":"Database Management Systems Lab","semester":4,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-02-24T10:02:15.189693+00:00","updated_at":"2026-07-14T16:44:28.127+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"d774ea15-8365-4c97-91ac-d5760f777de8","class_code":"EC-CG","parent_class_code":"EC2428,YI9I9UW7","code_lang":null,"name":"CG","description":"Computer Graphics Lab","semester":4,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-02-26T10:54:01.419263+00:00","updated_at":"2026-07-14T16:44:28.128+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"e3ef9e1a-f5e9-4d25-ab83-2aecf773a394","class_code":"CXQ3AY","parent_class_code":"EC2428,YI9I9UW7","code_lang":null,"name":"Control of Robotics","description":"","semester":4,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-07-28T05:21:13.34+00:00","updated_at":"2026-07-28T05:21:13.34+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"bb17cacf-1648-498d-b788-4cb795a0613e","class_code":"MGQDAZ","parent_class_code":"EC2428","code_lang":null,"name":"COA","description":"Computer Organization and Architecture","semester":5,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-08-27T06:59:32.213171+00:00","updated_at":"2026-08-27T06:59:32.213171+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"211bd610-711d-4b7d-97c0-1f13035c05c6","class_code":"DFNVEX","parent_class_code":"EC2428","code_lang":null,"name":"OS","description":"Operating System","semester":5,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-08-27T07:38:45.814701+00:00","updated_at":"2026-08-27T07:38:45.814701+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"314fae7c-fd34-46e1-bf43-25b1cabd5188","class_code":"D77JNW","parent_class_code":"EC2428","code_lang":null,"name":"VLSI","description":"Very Large Scale Integration","semester":5,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-08-27T07:39:57.330144+00:00","updated_at":"2026-08-27T07:39:57.330144+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"24ee6e79-556a-44c6-9edb-d69a61e14b77","class_code":"ZGG3RF","parent_class_code":"EC2428","code_lang":null,"name":"ARM","description":"ARM Microcontroller and Embedded Systems","semester":5,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-08-27T07:40:22.275644+00:00","updated_at":"2026-08-27T07:40:22.275644+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"},{"id":"0aa2b802-3787-420a-95db-7a1bd7321420","class_code":"XPEN5V","parent_class_code":"EC2428","code_lang":null,"name":"ITC","description":"Information Theory and Coding","semester":5,"is_active":true,"is_deleted":false,"created_by":"850f2073-4185-49f3-bb30-558183b573f3","institute":"AIEM","branch":"Electronics and Computer Engineering","created_at":"2026-08-27T07:39:40.537329+00:00","updated_at":"2026-08-27T07:39:40.537329+00:00","is_archived":false,"isOwner":false,"owner_name":"Nathan Lobo","owner_avatar_color_seed":"d741229b-449c-49d2-a50b-2b484b9d8c7b"}],"initialExperiments":[{"id":"0901f850-524f-4840-9513-bd20efed1338","parent_id":"ad724ec4-c2b1-545d-80b6-33b8ff4dd908","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"b","name":"8 connected flood fill","description":"","file_id":"a232e4ad-60d2-4598-84b1-b5ad6c9616be","file_path":"experiments/a232e4ad-60d2-4598-84b1-b5ad6c9616be.c","original_filename":"expt5b.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811963/lab/experiments/a232e4ad-60d2-4598-84b1-b5ad6c9616be_zdxinm.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T03:22:48.328+00:00","updated_at":"2026-07-17T03:22:48.328+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"5","parentId":"ad724ec4-c2b1-545d-80b6-33b8ff4dd908","subExptNo":"b","subExptName":"8 connected flood fill","exptName":"exp5","status":"approved","filePath":"experiments/a232e4ad-60d2-4598-84b1-b5ad6c9616be.c","originalFilename":"expt5b.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"91af6fc8-09f5-5dc1-a663-de386236d572","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"1","name":"Line DDA Algorithm (Digital Differential Analyer)","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-02-26T16:58:01.926758+00:00","updated_at":"2026-03-19T12:35:04.974+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"1","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Line DDA Algorithm (Digital Differential Analyer)","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"7936b696-7699-5c14-8f18-aeb02c2e9d3b","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"2","name":"Bresenham's Line algorithm","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T10:38:57.246887+00:00","updated_at":"2026-03-11T23:40:11.957+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"2","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Bresenham's Line algorithm","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"b56b5ec7-02e4-563d-b68f-76da261b4122","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"3","name":"Circle Midpoint Algorithm","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-02-26T10:55:47.867874+00:00","updated_at":"2026-03-19T12:35:04.867+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"3","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Circle Midpoint Algorithm","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"8b4d31b5-d720-5457-858d-12db084a650a","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"4","name":"Midpoint Ellipse Drawing Algorithm","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T10:46:25.014139+00:00","updated_at":"2026-03-11T23:50:19.149+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"4","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Midpoint Ellipse Drawing Algorithm","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"ad724ec4-c2b1-545d-80b6-33b8ff4dd908","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"5","name":"exp5","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-16T21:45:00.298+00:00","updated_at":"2026-07-17T03:20:27.497+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"5","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"exp5","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"6","name":"Expt6","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:35:47.221+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Expt6","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"e2393416-0241-562d-89b8-0131d0864080","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"7","name":"Text formatting using settextstyle & outtextxy","description":null,"file_id":null,"file_path":null,"original_filename":null,"file_extension":null,"file_url":null,"storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T04:28:51.181+00:00","updated_at":"2026-07-17T04:30:00.642+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"7","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Text formatting using settextstyle & outtextxy","status":"approved","filePath":null,"originalFilename":"","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"40726ff0-29b9-4a14-a031-8febee7fa5e5","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"8","name":"Polygon scanline filling algo","description":"","file_id":"4ec6b4b8-dc88-4f2b-a1c6-0c914bfb5925","file_path":"experiments/4ec6b4b8-dc88-4f2b-a1c6-0c914bfb5925.c","original_filename":"Expt8.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811914/lab/experiments/4ec6b4b8-dc88-4f2b-a1c6-0c914bfb5925_ek83nj.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T03:09:05.954+00:00","updated_at":"2026-07-17T03:09:05.954+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"8","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Polygon scanline filling algo","status":"approved","filePath":"experiments/4ec6b4b8-dc88-4f2b-a1c6-0c914bfb5925.c","originalFilename":"Expt8.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"dc9e9430-b33d-4dcc-9fc5-7822fdc3b7a3","parent_id":null,"subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"9","name":"Cohen-Sutherland Line Clipping algorithm.","description":"","file_id":"a266437f-cf83-47be-b79a-4ec784de842c","file_path":"experiments/a266437f-cf83-47be-b79a-4ec784de842c.c","original_filename":"Expt9.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811964/lab/experiments/a266437f-cf83-47be-b79a-4ec784de842c_ryptk8.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T03:14:28.449+00:00","updated_at":"2026-07-17T03:14:28.449+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"9","parentId":null,"subExptNo":null,"subExptName":null,"exptName":"Cohen-Sutherland Line Clipping algorithm.","status":"approved","filePath":"experiments/a266437f-cf83-47be-b79a-4ec784de842c.c","originalFilename":"Expt9.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"40ca0f05-3c5f-4198-bcb2-fb3107311ac3","parent_id":"ad724ec4-c2b1-545d-80b6-33b8ff4dd908","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"a","name":"4-Connected Flood Fill","description":"","file_id":"1883f6ba-211d-4907-90d2-3a7a54bd5537","file_path":"experiments/1883f6ba-211d-4907-90d2-3a7a54bd5537.c","original_filename":"exp5a.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811890/lab/experiments/1883f6ba-211d-4907-90d2-3a7a54bd5537_fxabjj.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-16T21:45:00.298+00:00","updated_at":"2026-07-17T03:20:27.497+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"5","parentId":"ad724ec4-c2b1-545d-80b6-33b8ff4dd908","subExptNo":"a","subExptName":"4-Connected Flood Fill","exptName":"exp5","status":"approved","filePath":"experiments/1883f6ba-211d-4907-90d2-3a7a54bd5537.c","originalFilename":"exp5a.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"244db82e-274f-45ec-826b-e439ea3b5998","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"a","name":"Drawing a diagonal line in quadrant 1","description":"","file_id":"3e1822b0-f55f-4f67-8114-de131beee31e","file_path":"experiments/3e1822b0-f55f-4f67-8114-de131beee31e.c","original_filename":"Expt6a.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811906/lab/experiments/3e1822b0-f55f-4f67-8114-de131beee31e_kbwfq3.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:35:47.221+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"a","subExptName":"Drawing a diagonal line in quadrant 1","exptName":"Expt6","status":"approved","filePath":"experiments/3e1822b0-f55f-4f67-8114-de131beee31e.c","originalFilename":"Expt6a.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"9cfe0353-4aac-40ad-8b73-6621303f5c83","parent_id":"b56b5ec7-02e4-563d-b68f-76da261b4122","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"A","name":"To Draw a circle using Circle Midpoint Algo at the center of the screen","description":"","file_id":"a77888ca-434b-403b-978a-63cadac7b6ff","file_path":"experiments/a77888ca-434b-403b-978a-63cadac7b6ff.c","original_filename":"EXPT3A.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811969/lab/experiments/a77888ca-434b-403b-978a-63cadac7b6ff_aaoifb.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-02-26T10:55:47.867874+00:00","updated_at":"2026-03-19T12:35:04.867+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"3","parentId":"b56b5ec7-02e4-563d-b68f-76da261b4122","subExptNo":"A","subExptName":"To Draw a circle using Circle Midpoint Algo at the center of the screen","exptName":"Circle Midpoint Algorithm","status":"approved","filePath":"experiments/a77888ca-434b-403b-978a-63cadac7b6ff.c","originalFilename":"EXPT3A.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"8b2a9d23-c66d-4aea-a3e5-d42858b11310","parent_id":"91af6fc8-09f5-5dc1-a663-de386236d572","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"A","name":"To draw a line using Line DDA Algorithm","description":"","file_id":"6a841b0d-2322-4321-953a-c4d366bd0feb","file_path":"experiments/6a841b0d-2322-4321-953a-c4d366bd0feb.c","original_filename":"EXPT1A.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811931/lab/experiments/6a841b0d-2322-4321-953a-c4d366bd0feb_y9udsc.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-02-26T16:58:01.926758+00:00","updated_at":"2026-03-19T12:35:04.974+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"1","parentId":"91af6fc8-09f5-5dc1-a663-de386236d572","subExptNo":"A","subExptName":"To draw a line using Line DDA Algorithm","exptName":"Line DDA Algorithm (Digital Differential Analyer)","status":"approved","filePath":"experiments/6a841b0d-2322-4321-953a-c4d366bd0feb.c","originalFilename":"EXPT1A.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"910db05d-338e-41d3-8bb8-f518c7e3c6ba","parent_id":"7936b696-7699-5c14-8f18-aeb02c2e9d3b","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"A","name":"Draw a line using Bresenham's Line algorithm","description":"","file_id":"5ea8a5ef-6aa2-4084-8c5f-61baca91081c","file_path":"experiments/5ea8a5ef-6aa2-4084-8c5f-61baca91081c.c","original_filename":"EXPT2A.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811924/lab/experiments/5ea8a5ef-6aa2-4084-8c5f-61baca91081c_enplxp.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T10:38:57.246887+00:00","updated_at":"2026-03-11T23:40:11.957+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"2","parentId":"7936b696-7699-5c14-8f18-aeb02c2e9d3b","subExptNo":"A","subExptName":"Draw a line using Bresenham's Line algorithm","exptName":"Bresenham's Line algorithm","status":"approved","filePath":"experiments/5ea8a5ef-6aa2-4084-8c5f-61baca91081c.c","originalFilename":"EXPT2A.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"fedb4061-52cb-447d-9081-9bc243acefa7","parent_id":"8b4d31b5-d720-5457-858d-12db084a650a","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"A","name":"Draw a vertical & horizontal Ellipse using Midpoint Ellipse Algorithm","description":"","file_id":"45ffc594-6747-4347-ae86-0beafed3bc11","file_path":"experiments/45ffc594-6747-4347-ae86-0beafed3bc11.c","original_filename":"EXPT4A.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811910/lab/experiments/45ffc594-6747-4347-ae86-0beafed3bc11_qhmkpj.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T10:46:25.014139+00:00","updated_at":"2026-03-11T23:50:19.149+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"4","parentId":"8b4d31b5-d720-5457-858d-12db084a650a","subExptNo":"A","subExptName":"Draw a vertical & horizontal Ellipse using Midpoint Ellipse Algorithm","exptName":"Midpoint Ellipse Drawing Algorithm","status":"approved","filePath":"experiments/45ffc594-6747-4347-ae86-0beafed3bc11.c","originalFilename":"EXPT4A.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"82633aab-0638-4bc4-977d-19d200441bc7","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"b","name":"Line Rotated by angle of 45°","description":"","file_id":"2647c688-fed3-4ba2-b0b4-eeef116d2edd","file_path":"experiments/2647c688-fed3-4ba2-b0b4-eeef116d2edd.c","original_filename":"Expt6b.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811898/lab/experiments/2647c688-fed3-4ba2-b0b4-eeef116d2edd_supm2x.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:38:55.823+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"b","subExptName":"Line Rotated by angle of 45°","exptName":"Expt6","status":"approved","filePath":"experiments/2647c688-fed3-4ba2-b0b4-eeef116d2edd.c","originalFilename":"Expt6b.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"21f4130c-f47e-44a3-89c7-a0e0e203cd02","parent_id":"e2393416-0241-562d-89b8-0131d0864080","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"b","name":"Text formatting using settextstyle & outtextxy","description":"","file_id":"8b1a22c3-5626-4bbf-b9dc-06438b7a02e0","file_path":"experiments/8b1a22c3-5626-4bbf-b9dc-06438b7a02e0.c","original_filename":"expt7b.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811950/lab/experiments/8b1a22c3-5626-4bbf-b9dc-06438b7a02e0_zlfg0r.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T04:28:51.181+00:00","updated_at":"2026-07-17T04:30:00.642+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"7","parentId":"e2393416-0241-562d-89b8-0131d0864080","subExptNo":"b","subExptName":"Text formatting using settextstyle & outtextxy","exptName":"Text formatting using settextstyle & outtextxy","status":"approved","filePath":"experiments/8b1a22c3-5626-4bbf-b9dc-06438b7a02e0.c","originalFilename":"expt7b.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"1d56d7e6-6013-4f1c-9e5f-3ecc02d46615","parent_id":"b56b5ec7-02e4-563d-b68f-76da261b4122","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"B","name":"To draw quarter circles at corners of the screen and a House with a Sun","description":"","file_id":"e173c48d-e2c4-4f4a-96df-3ec9b81a599d","file_path":"experiments/e173c48d-e2c4-4f4a-96df-3ec9b81a599d.c","original_filename":"EXPT3B.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811996/lab/experiments/e173c48d-e2c4-4f4a-96df-3ec9b81a599d_b9vvl8.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-02-26T10:58:24.963765+00:00","updated_at":"2026-03-19T12:35:04.922+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"3","parentId":"b56b5ec7-02e4-563d-b68f-76da261b4122","subExptNo":"B","subExptName":"To draw quarter circles at corners of the screen and a House with a Sun","exptName":"Circle Midpoint Algorithm","status":"approved","filePath":"experiments/e173c48d-e2c4-4f4a-96df-3ec9b81a599d.c","originalFilename":"EXPT3B.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"abc1cc16-14b8-4db7-92d9-d94b003c2c98","parent_id":"91af6fc8-09f5-5dc1-a663-de386236d572","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"B","name":"To draw a simple robo face using Line DDA Algorithm","description":"","file_id":"27ccf0ce-a87d-40e6-9a1a-a36384b48b21","file_path":"experiments/27ccf0ce-a87d-40e6-9a1a-a36384b48b21.c","original_filename":"EXPT1B.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811898/lab/experiments/27ccf0ce-a87d-40e6-9a1a-a36384b48b21_dtsmqu.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-02-26T17:01:54.88312+00:00","updated_at":"2026-03-19T12:35:05.025+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"1","parentId":"91af6fc8-09f5-5dc1-a663-de386236d572","subExptNo":"B","subExptName":"To draw a simple robo face using Line DDA Algorithm","exptName":"Line DDA Algorithm (Digital Differential Analyer)","status":"approved","filePath":"experiments/27ccf0ce-a87d-40e6-9a1a-a36384b48b21.c","originalFilename":"EXPT1B.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"b0ef5fc1-edc2-467d-b05f-5b6f176029c1","parent_id":"8b4d31b5-d720-5457-858d-12db084a650a","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"B","name":"Draw an eye using Midpoint Ellipse Algorithm","description":"","file_id":"dcf967e6-8eca-49f5-bee4-b42cdff863b3","file_path":"experiments/dcf967e6-8eca-49f5-bee4-b42cdff863b3.c","original_filename":"EXPT4B.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811993/lab/experiments/dcf967e6-8eca-49f5-bee4-b42cdff863b3_rwdp3v.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T10:49:32.574722+00:00","updated_at":"2026-03-12T05:19:32.574722+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"4","parentId":"8b4d31b5-d720-5457-858d-12db084a650a","subExptNo":"B","subExptName":"Draw an eye using Midpoint Ellipse Algorithm","exptName":"Midpoint Ellipse Drawing Algorithm","status":"approved","filePath":"experiments/dcf967e6-8eca-49f5-bee4-b42cdff863b3.c","originalFilename":"EXPT4B.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"ad17aa3c-0aa3-4227-81a3-881120c0bf15","parent_id":"7936b696-7699-5c14-8f18-aeb02c2e9d3b","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"B","name":"Draw a house using Bresenham's Line Drawing Algorithm","description":"","file_id":"743497bf-2631-4ccc-aea9-0d6696ab71c1","file_path":"experiments/743497bf-2631-4ccc-aea9-0d6696ab71c1.c","original_filename":"EXPT2B.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811937/lab/experiments/743497bf-2631-4ccc-aea9-0d6696ab71c1_jlzl09.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T11:07:28.363515+00:00","updated_at":"2026-03-12T05:37:28.363515+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"2","parentId":"7936b696-7699-5c14-8f18-aeb02c2e9d3b","subExptNo":"B","subExptName":"Draw a house using Bresenham's Line Drawing Algorithm","exptName":"Bresenham's Line algorithm","status":"approved","filePath":"experiments/743497bf-2631-4ccc-aea9-0d6696ab71c1.c","originalFilename":"EXPT2B.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"8295de66-e277-4040-a55e-6daec2ab06b2","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"c","name":"Line Rotated by angle of 45° with reference to fixed point","description":"","file_id":"4800d424-77f1-463e-9877-b37552fcf655","file_path":"experiments/4800d424-77f1-463e-9877-b37552fcf655.c","original_filename":"Expt6c.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811911/lab/experiments/4800d424-77f1-463e-9877-b37552fcf655_ffxpvk.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:42:14.616+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"c","subExptName":"Line Rotated by angle of 45° with reference to fixed point","exptName":"Expt6","status":"approved","filePath":"experiments/4800d424-77f1-463e-9877-b37552fcf655.c","originalFilename":"Expt6c.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"a8475b38-4aaa-4839-bb22-2ffe1cc269fa","parent_id":"8b4d31b5-d720-5457-858d-12db084a650a","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"C","name":"Draw a flower using Midpoint Ellipse Algo & Lines","description":"","file_id":"e931dd96-cedd-4953-b9f3-c8998e084faf","file_path":"experiments/e931dd96-cedd-4953-b9f3-c8998e084faf.c","original_filename":"EXPT4C.C","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786812000/lab/experiments/e931dd96-cedd-4953-b9f3-c8998e084faf_otgxzr.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-03-12T10:51:41.823372+00:00","updated_at":"2026-03-12T05:21:41.823372+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"4","parentId":"8b4d31b5-d720-5457-858d-12db084a650a","subExptNo":"C","subExptName":"Draw a flower using Midpoint Ellipse Algo & Lines","exptName":"Midpoint Ellipse Drawing Algorithm","status":"approved","filePath":"experiments/e931dd96-cedd-4953-b9f3-c8998e084faf.c","originalFilename":"EXPT4C.C","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"a4c7b6d2-752c-4597-99ae-6de9bf6c80eb","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"d","name":"Drawing a square n scaling it up wrt fixed point","description":"","file_id":"a1c6a63b-af6f-4251-a525-52a579aaf669","file_path":"experiments/a1c6a63b-af6f-4251-a525-52a579aaf669.c","original_filename":"Expt6d.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811962/lab/experiments/a1c6a63b-af6f-4251-a525-52a579aaf669_ddq5ay.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:43:52.283+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"d","subExptName":"Drawing a square n scaling it up wrt fixed point","exptName":"Expt6","status":"approved","filePath":"experiments/a1c6a63b-af6f-4251-a525-52a579aaf669.c","originalFilename":"Expt6d.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"2a4ba26d-3a8d-42a2-bb25-4b120bd13dea","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"e","name":"Drawing a square n scaling it down wrt to fixed point","description":"","file_id":"d5851883-d783-4c03-8492-cea233fd359f","file_path":"experiments/d5851883-d783-4c03-8492-cea233fd359f.c","original_filename":"Expt6e.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811988/lab/experiments/d5851883-d783-4c03-8492-cea233fd359f_gsdujf.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:45:44.191+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"e","subExptName":"Drawing a square n scaling it down wrt to fixed point","exptName":"Expt6","status":"approved","filePath":"experiments/d5851883-d783-4c03-8492-cea233fd359f.c","originalFilename":"Expt6e.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"2c17896b-4dba-429d-bbb7-17e9b7a160d3","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"f","name":"Scaling up independently ie wrt origin","description":"","file_id":"6102c16d-57f4-492d-a965-f96720596af3","file_path":"experiments/6102c16d-57f4-492d-a965-f96720596af3.c","original_filename":"Expt6f.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811925/lab/experiments/6102c16d-57f4-492d-a965-f96720596af3_une1eh.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:49:49.078+00:00","updated_at":"2026-07-17T02:53:41.459+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"f","subExptName":"Scaling up independently ie wrt origin","exptName":"Expt6","status":"approved","filePath":"experiments/6102c16d-57f4-492d-a965-f96720596af3.c","originalFilename":"Expt6f.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"e0e6675e-70ab-4923-ac3d-4119d773f3d1","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"g","name":"Scaling down independently ie wrt origin","description":"","file_id":"fdad8c3c-d27a-4efa-9722-4bf83a516804","file_path":"experiments/fdad8c3c-d27a-4efa-9722-4bf83a516804.c","original_filename":"Expt6g.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786812007/lab/experiments/fdad8c3c-d27a-4efa-9722-4bf83a516804_yubqdv.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:51:55.818+00:00","updated_at":"2026-07-17T02:53:41.458+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"g","subExptName":"Scaling down independently ie wrt origin","exptName":"Expt6","status":"approved","filePath":"experiments/fdad8c3c-d27a-4efa-9722-4bf83a516804.c","originalFilename":"Expt6g.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"a5796a8a-5c59-4717-8954-005e8cfb6be3","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"h","name":"Drawing a triangle n show reflection across X, Y axis n origin","description":"","file_id":"f1f538f1-df30-4cc0-895f-b08a968bd4a4","file_path":"experiments/f1f538f1-df30-4cc0-895f-b08a968bd4a4.c","original_filename":"Expt6h.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786812004/lab/experiments/f1f538f1-df30-4cc0-895f-b08a968bd4a4_ofkoiq.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:56:48.756+00:00","updated_at":"2026-07-17T02:56:48.756+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"h","subExptName":"Drawing a triangle n show reflection across X, Y axis n origin","exptName":"Expt6","status":"approved","filePath":"experiments/f1f538f1-df30-4cc0-895f-b08a968bd4a4.c","originalFilename":"Expt6h.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true},{"id":"d0345ea6-ff84-4989-b6b6-22328a1c2e94","parent_id":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subject_id":"d774ea15-8365-4c97-91ac-d5760f777de8","expt_no":"i","name":"Vertical n Horizontal Shearing","description":"","file_id":"6acd2172-9dc3-494e-9e2c-57c9e6384500","file_path":"experiments/6acd2172-9dc3-494e-9e2c-57c9e6384500.c","original_filename":"Expt6i.c","file_extension":".c","file_url":"https://res.cloudinary.com/jsvaeoed/raw/upload/v1786811932/lab/experiments/6acd2172-9dc3-494e-9e2c-57c9e6384500_exgwpq.c","storage_type":"cloudinary","uploaded_by":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by":"850f2073-4185-49f3-bb30-558183b573f3","deleted_at":null,"created_at":"2026-07-17T02:58:47.969+00:00","updated_at":"2026-07-17T02:58:47.969+00:00","is_approved":true,"queries":[],"folder_path":null,"query_no":null,"query_name":null,"exptNo":"6","parentId":"d0c83ad4-ec4b-5ff5-88e3-7478b1f5c9b8","subExptNo":"i","subExptName":"Vertical n Horizontal Shearing","exptName":"Expt6","status":"approved","filePath":"experiments/6acd2172-9dc3-494e-9e2c-57c9e6384500.c","originalFilename":"Expt6i.c","uploaded_by_id":"850f2073-4185-49f3-bb30-558183b573f3","uploaded_by_name":"Nathan Lobo","uploaded_by_roll_number":"25LEC07","uploaded_by_is_student_verified":true,"last_edited_by_id":"850f2073-4185-49f3-bb30-558183b573f3","last_edited_by_name":"Nathan Lobo","last_edited_by_roll_number":"25LEC07","last_edited_by_is_student_verified":true}],"initialPublicExplanations":{"40726ff0-29b9-4a14-a031-8febee7fa5e5":{"explanation":"This C program implements a specific solution with clear functionality. Let me provide a detailed breakdown:\n\n**Program Purpose:**\nBased on the program comments: \"Choose fill color\". This gives us clear insight into what the program is designed to accomplish.\n\n**Core Algorithm:**\nUses a for loop structure for controlled iteration:\n- Provides precise control over the number of iterations\n- Each iteration performs a specific calculation or operation\n- Loop variable manages the progression through the algorithm\n\n**Logic Flow Analysis:**\n- **Conditional Logic**: Uses decision-making statements to handle different scenarios and control program flow\n\n\n**Input/Output Operations:**\n- Standard input/output operations for user interaction.\n\n**Execution Summary:**\nThe program executes in the following sequence:\n4. **Processing Loop**: Executes the main algorithm through iterative operations\n\nThis structured approach ensures reliable execution and proper resource management.","algorithm":"**Algorithm Steps:**\n\n1. **Program Initialization**: Start the C program execution.\n2. **Iterative Processing**: Execute loop structures to process data or perform repeated operations.\n3. **Conditional Logic**: Apply decision-making logic using if-else statements to handle different scenarios.\n4. **Core Processing**: Execute the main logic to solve the given problem.\n5. **Output Generation**: Display the computed results or final output to the user.\n6. **Program Termination**: Complete the execution and terminate the program.\n\n**Time Complexity**: The algorithm runs in a time complexity that depends on the number of operations and loop iterations.\n**Space Complexity**: Memory usage is determined by the number of variables and data structures used."},"dc9e9430-b33d-4dcc-9fc5-7822fdc3b7a3":{"explanation":"This C program implements a specific solution with clear functionality. Let me provide a detailed breakdown:\n\n**Program Purpose:**\nBased on the program comments: \"Clipping window\". This gives us clear insight into what the program is designed to accomplish.\n\n**Core Algorithm:**\nThe program implements a systematic approach to solve the given problem through logical step-by-step processing.\n\n**Logic Flow Analysis:**\n- **Conditional Logic**: Uses decision-making statements to handle different scenarios and control program flow\n\n\n**Input/Output Operations:**\n- Standard input/output operations for user interaction.\n\n**Execution Summary:**\nThe program executes in the following sequence:\n4. **Processing Loop**: Executes the main algorithm through iterative operations\n\nThis structured approach ensures reliable execution and proper resource management.","algorithm":"**Algorithm Steps:**\n\n1. **Program Initialization**: Start the C program execution.\n2. **Iterative Processing**: Execute loop structures to process data or perform repeated operations.\n3. **Conditional Logic**: Apply decision-making logic using if-else statements to handle different scenarios.\n4. **Core Processing**: Execute the main logic to solve the given problem.\n5. **Output Generation**: Display the computed results or final output to the user.\n6. **Program Termination**: Complete the execution and terminate the program.\n\n**Time Complexity**: The algorithm runs in a time complexity that depends on the number of operations and loop iterations.\n**Space Complexity**: Memory usage is determined by the number of variables and data structures used."},"ad17aa3c-0aa3-4227-81a3-881120c0bf15":{"explanation":"$49","algorithm":"$4a"},"a8475b38-4aaa-4839-bb22-2ffe1cc269fa":{"explanation":"$4b","algorithm":"$4c"},"b0ef5fc1-edc2-467d-b05f-5b6f176029c1":{"explanation":"$4d","algorithm":"The Midpoint Ellipse Drawing Algorithm proceeds in two main regions due to the changing slope of the ellipse. It leverages 4-way symmetry to draw the entire ellipse by calculating points for only one quadrant.\n\nHere are the steps:\n\n1. **Initialize Graphics**: Set up the graphics environment (e.g., using B"},"fedb4061-52cb-447d-9081-9bc243acefa7":{"explanation":"$4e","algorithm":"$4f"},"910db05d-338e-41d3-8bb8-f518c7e3c6ba":{"explanation":"This C program demonstrates Bresenham's Line Algorithm, a fundamental technique in computer graphics for drawing lines. It uses the `graphics.h` library, a common library in older C/C++ compilers (like Turbo C/C++) for simple graphical operations.\n\nThe program works in two main parts:\n1. **Setting up the Graphics Environment:** The `main` function initializes the graphics mode, which essentially opens a graphical window where drawing can occur.\n2. **Drawing the Line:** The `lineBres` function contains the core logic of Bresenham's algorithm. It takes two points (`(xa, ya)` and `(xb, yb)`) and calculates which pixels should be turned \"on\" to form a straight line between them","algorithm":null},"abc1cc16-14b8-4db7-92d9-d94b003c2c98":{"explanation":"$50","algorithm":"$51"},"8b2a9d23-c66d-4aea-a3e5-d42858b11310":{"explanation":"$52","algorithm":"$53"},"1d56d7e6-6013-4f1c-9e5f-3ecc02d46615":{"explanation":"$54","algorithm":"$55"},"9cfe0353-4aac-40ad-8b73-6621303f5c83":{"explanation":"$56","algorithm":"$57"}},"initialTrashedInfo":null}}]