line_drawing_utils.cpp

//
// Created by kobedb on 20.05.22.
//

#include "line_drawing_utils.h"

#include <iostream>

using namespace std;

namespace KDBRenderUtils
{
    void draw2DLine(img::EasyImage& image, Point2D left, Point2D right, img::Color c)
    {
        if( false )
        {
            cerr << "ERROR: Tried to draw a line whose point(s) lay out of bounds!\n";
            return;
        }

        if(left.x > right.x) {
            auto temp = left;
            left = right;
            right = temp;
        }

        int startX = ceil(left.x);
        int startY = ceil(left.y);
        int endX = ceil(right.x);
        int endY = ceil(right.y);

        // !!!! Test this before calculating m to prevent division by 0 !!!!
        if ( startX == endX ) {
            int StartDrawY = left.y < right.y ? ceil(left.y) : ceil(right.y);
            auto amtStepsY =  abs(startY - endY);
            for ( int i = 0; i < amtStepsY; i++ ) {
                image(startX, StartDrawY + i) = c;
            }
        }

        double m = (double)(endY - startY) / (endX - startX); // cast to double needed to perform floating point division

        if( startY == endY) {
            for( int i = 0; i < endX - startX; i++) {
                image(startX + i, startY) = c;
            }
        }

        if( (0 < m && m <= 1) || (-1 <= m && m < 0) ) {
            for( int i = 0; i < endX - startX; i++) {
                image(startX + i, round(startY + m * i)) = c;
            }
        }

        if(m > 1) {
            for( int i = 0; i < endY - startY; i++) {
                image(round(startX + i/m), startY + i) = c;
            }
        }

        if( m < -1) {
            for( int i = 0; i < startY - endY; i++) {
                image(round(startX - i/m), startY - i) = c;
            }
        }
    }


    void draw2DZBufLine(ZBuffer& zBuffer, img::EasyImage& image, Point2D point0, double z0, Point2D point1, double z1, img::Color c)
    {
        Point2D left = point0;
        Point2D right = point1;
        if(left.x > right.x) {
//            auto temp = left;
//            left = right;
//            right = temp;
            std::swap(left, right);
            std::swap(z0,z1); // Very Important, as z0 belongs to point0, and z1 belongs to point1!! (I think)
        }

        int startX = ceil(left.x);
        int startY = ceil(left.y);
        int endX = ceil(right.x);
        int endY = ceil(right.y);

        int dx = abs(endX - startX);
        int dy = abs(endY - startY);

        // !!!! Test this before calculating m to prevent division by 0 !!!!
        if ( startX == endX ) {
            int StartDrawY = left.y < right.y ? ceil(left.y) : ceil(right.y);
            auto amtStepsY =  abs(startY - endY);
            for ( int i = 0; i < amtStepsY; i++ ) {
                double p = (double)(dy - i) / dy;
                double reciprocal_z_I = p / z0 + ( 1 - p )/z1;
                unsigned pix_X = startX;
                unsigned pix_Y = StartDrawY + i;
                drawAndUpdateZBuffer(image, zBuffer, pix_X, pix_Y, reciprocal_z_I, c);
            }
        }

        double m = (double)(endY - startY) / (endX - startX); // cast to double needed to perform floating point division

        if( startY == endY) {
            for( int i = 0; i < endX - startX; i++) {
                double p = (double)(dx - i) / dx;
                double reciprocal_z_I = p / z0 + ( 1 - p )/z1;
                unsigned pix_X = startX + i;
                unsigned pix_Y = startY;
                drawAndUpdateZBuffer(image, zBuffer, pix_X, pix_Y, reciprocal_z_I, c);
            }
        }

        if( (0 < m && m <= 1) || (-1 <= m && m < 0) ) {
            for( int i = 0; i < endX - startX; i++)
            {
                double p = (double)(dx - i) / dx;
                double reciprocal_z_I = p / z0 + ( 1 - p )/z1;
                unsigned pix_X = startX + i;
                unsigned pix_Y = round(startY + m * i);
                drawAndUpdateZBuffer(image, zBuffer, pix_X, pix_Y, reciprocal_z_I, c);
            }
        }

        if(m > 1) {
            for( int i = 0; i < endY - startY; i++) {
                double p = (double)(dy - i) / dy;
                double reciprocal_z_I = p / z0 + ( 1 - p )/z1;
                unsigned pix_X = round(startX + i/m);
                unsigned pix_Y = startY + i;
                drawAndUpdateZBuffer(image, zBuffer, pix_X, pix_Y, reciprocal_z_I, c);
            }
        }

        if( m < -1) {
            for( int i = 0; i < startY - endY; i++) {
                double p = (double)(dy - i) / dy;
                double reciprocal_z_I = p / z0 + ( 1 - p )/z1;
                unsigned pix_X = round(startX - i/m);
                unsigned pix_Y = startY - i;
                drawAndUpdateZBuffer(image, zBuffer, pix_X, pix_Y, reciprocal_z_I, c);
            }
        }
    }


    img::EasyImage draw2DLines(const std::vector<Line2D>& lines, unsigned size, NormColor backgroundcolor)
    {
        double d, dx, dy;
        unsigned imageX, imageY;
        calcPointTransformationsFor2DLines(lines, size, d, dx, dy, imageX, imageY);
        img::EasyImage image{imageX, imageY, toEasyImgColor(backgroundcolor)};
        for(const auto& line : lines) {
            Point2D first = line.p0 * d + Point2D{dx, dy};
            Point2D second = line.p1 * d + Point2D{dx, dy};
            draw2DLine(image, first, second, toEasyImgColor(line.c));
            //draw2DZBufLine(zBuffer, image, first, line.z1, second, line.z2, toEasyImgColor(line.c));
        }

        return image;
    }

    img::EasyImage draw2DLines(ZBuffer& zBuffer, const std::vector<Line2D>& lines, unsigned size, NormColor backgroundcolor)
    {
        double d, dx, dy;
        unsigned imageX, imageY;
        calcPointTransformationsFor2DLines(lines, size, d, dx, dy, imageX, imageY);
        img::EasyImage image{imageX, imageY, toEasyImgColor(backgroundcolor)};
        for(const auto& line : lines) {
            Point2D first = line.p0 * d + Point2D{dx, dy};
            Point2D second = line.p1 * d + Point2D{dx, dy};
            draw2DZBufLine(zBuffer, image, first, line.z1, second, line.z2, toEasyImgColor(line.c));
        }

        return image;
    }

    void updateIfBigger(double maybeBigger, double& max )
    {
        if(maybeBigger > max) {
            max = maybeBigger;
        }
    }

    void updateIfSmaller(double maybeSmaller, double& min)
    {
        if(maybeSmaller < min) {
            min = maybeSmaller;
        }
    }

    void calcPointTransformationsFor2DLines(const std::vector<Line2D>& lines, unsigned size,
                                            double& d, double& dx, double& dy, unsigned& imageX, unsigned& imageY)
    {
        constexpr double infinity{std::numeric_limits<int>::max()};
        double xmax{-infinity}, xmin{infinity}, ymax{-infinity}, ymin{infinity};
        for(const auto& line : lines) {
            updateIfBigger(line.p0.x, xmax);
            updateIfBigger(line.p1.x, xmax);
            updateIfBigger(line.p0.y, ymax);
            updateIfBigger(line.p1.y, ymax);
            updateIfSmaller(line.p0.x, xmin);
            updateIfSmaller(line.p1.x, xmin);
            updateIfSmaller(line.p0.y, ymin);
            updateIfSmaller(line.p1.y, ymin);
        }

        double xrange = xmax - xmin;
        double yrange = ymax - ymin;

        imageX = size * xrange / std::max(xrange, yrange);
        imageY = size * yrange / std::max(xrange, yrange);

        d = 0.95 * imageX/xrange;

        double DCx = d * (xmax + xmin) / 2;
        double DCy = d * (ymax + ymin) / 2;
        dx = ((double)imageX/2) - DCx;
        dy = ((double)imageY/2) - DCy;
    }
}