#include<iostream.h>  // Standard input-output stream
#include<math.h>      // cos(), sin() for rotation
#include<graphics.h>  // Turbo C++ graphics library
#include<conio.h>     // Console input-output (getch, clrscr)
#include<stdio.h>     // Standard I/O

// Forward declarations of transformation functions
void applyTranslation(int x1, int y1, int x2, int y2);
void applyScaling(int x1, int y1, int x2, int y2);
void applyRotation(int x1, int y1, int x2, int y2);

void main()
{
    int startX, startY, endX, endY; // Endpoints of the original line
    int choice;                     // User's transformation choice
    char continueAnswer;            // Whether to apply another transformation

    int graphicsDriver = DETECT, graphicsMode;
    clrscr();
    initgraph(&graphicsDriver, &graphicsMode, "C:\\tc\\bgi");

    // Read the original line endpoints from the user
    cout << "Enter the endpoints of the line (x1 y1 x2 y2):n";
    cin  >> startX >> startY >> endX >> endY;
    line(startX, startY, endX, endY); // Draw the original line

    // Allow the user to apply multiple transformations in sequence
    do
    {
        cout << "\nChoose transformation:\n";
        cout << "  1 --> Translationn";
        cout << "  2 --> Scalingn";
        cout << "  3 --> Rotationn";
        cin  >> choice;

        switch (choice)
        {
            case 1: applyTranslation(startX, startY, endX, endY); break;
            case 2: applyScaling(startX, startY, endX, endY);     break;
            case 3: applyRotation(startX, startY, endX, endY);    break;
            default: break;
        }

        cout << "\nApply another transformation? (Y / N): ";
        cin  >> continueAnswer;

    } while (continueAnswer == 'y' || continueAnswer == 'Y');

    getch();
    closegraph();
}

// Translation: shifts both endpoints by (translateX, translateY)
void applyTranslation(int startX, int startY, int endX, int endY)
{
    int translateX, translateY;
    cout << "\nEnter translation factors (tx ty): ";
    cin  >> translateX >> translateY;

    // Apply translation to both endpoints
    startX += translateX;  startY += translateY;
    endX   += translateX;  endY   += translateY;

    cout << "Translated line:n";
    line(startX, startY, endX, endY);
}

// Scaling: multiplies both endpoints by scale factors (scaleX, scaleY)
void applyScaling(int startX, int startY, int endX, int endY)
{
    int scaleX, scaleY;
    cout << "\nEnter scaling factors (sx sy): ";
    cin  >> scaleX >> scaleY;

    // Apply uniform scaling from the origin
    startX *= scaleX;  startY *= scaleY;
    endX   *= scaleX;  endY   *= scaleY;

    cout << "Scaled line:n";
    line(startX, startY, endX, endY);
}

// Rotation: rotates the end point by theta degrees about the origin
// (the start point is kept fixed in this implementation)
void applyRotation(int startX, int startY, int endX, int endY)
{
    int rotationAngle;
    cout << "\nEnter rotation angle (theta in degrees): ";
    cin  >> rotationAngle;

    // Apply 2-D rotation matrix to the end point
    // newX = x*cos(theta) - y*sin(theta)
    // newY = y*cos(theta) + x*sin(theta)
    int rotatedEndX = (int)((endX * cos(rotationAngle)) - (endY * sin(rotationAngle)));
    int rotatedEndY = (int)((endY * cos(rotationAngle)) + (endX * sin(rotationAngle)));

    cout << "Rotated line:n";
    line(startX, startY, rotatedEndX, rotatedEndY);
}