BulgeConverter.h

Go to the documentation of this file.

#pragma once
#include "Base/Headers/AngleFunctions.h"
#include "Base/Headers/Vertex.hpp"
namespace NDEVR
{
    /* Line Intersection
     * intersectX and intersectY are set to the CenterPoint */
    Vertex<3, fltp08> getLineIntersection(double  lineAx1, double  lineAy1,
        double  lineAx2, double  lineAy2,
        double  lineBx1, double  lineBy1,
        double  lineBx2, double  lineBy2)
    {
        double A1 = lineAy2 - lineAy1;
        double B1 = lineAx1 - lineAx2;
        double C1 = A1 * lineAx1 + B1 * lineAy1;
 
        double A2 = lineBy2 - lineBy1;
        double B2 = lineBx1 - lineBx2;
        double C2 = A2 * lineBx1 + B2 * lineBy1;
 
        double det = A1 * B2 - A2 * B1;
        Vertex<3, fltp08> center;
        if (det == 0)
        {
            printf("Intersecting lines cannot be parallel.\n");
        }
        else
        {
            center[X] = (B2 * C1 - B1 * C2) / det;
            center[Y] = (A1 * C2 - A2 * C1) / det;
        }
        return center;
    }
    /* Calculus based approach at determining whether a polygon is clockwise or counterclockwise.
    * Returns true if arc is clockwise. */
    bool isArcClockwise(double startx, double starty, double midx, double midy, double endx, double endy)
    {
        double edge1 = (midx - startx) * (midy + starty);
        double edge2 = (endx - midx) * (endy + midy);
        double edge3 = (startx - endx) * (starty + endy);
        return (edge1 + edge2 + edge3 >= 0.0);
    }
 
    /* Calculates the CenterPoint of the Arc */
    Vertex<3, fltp08> getArcCenter(double  arcStartX, double  arcStartY,
        double  arcMidX, double  arcMidY,
        double  arcEndX, double  arcEndY)
    {
        double ax = arcMidX - arcStartX;
        double ay = arcMidY - arcStartY;
        Angle<fltp08> aAngleInRadians = Angle<fltp08>::atan2(ay, ax);
        double aMidX = (arcMidX + arcStartX) / 2.0;
        double aMidY = (arcMidY + arcStartY) / 2.0;
 
        Angle<fltp08> paAngleInRadians = aAngleInRadians + Angle<fltp08>(DEGREES, 90.0);
        double pax = cos(paAngleInRadians);
        double pay = sin(paAngleInRadians);
        double aPerpX = aMidX + pax;
        double aPerpY = aMidY + pay;
 
        double bx = arcEndX - arcMidX;
        double by = arcEndY - arcMidY;
        Angle<fltp08> bAngleInRadians = Angle<fltp08>::atan2(by, bx);
        double bMidX = (arcEndX + arcMidX) / 2.0;
        double bMidY = (arcEndY + arcMidY) / 2.0;
 
        Angle<fltp08> pbAngleInRadians = bAngleInRadians + Angle<fltp08>(DEGREES, 90.0);
        double pbx = cos(pbAngleInRadians);
        double pby = sin(pbAngleInRadians);
        double bPerpX = bMidX + pbx;
        double bPerpY = bMidY + pby;
 
        return getLineIntersection(aMidX, aMidY, aPerpX, aPerpY, bMidX, bMidY, bPerpX, bPerpY);
    }
 
    /* Calculates Arc Geometry from Bulge Data.
     * Returns false if there was an error calculating the data. */
    void ArcDataFromBulge(fltp08 bulge, const Vertex<3, fltp08>& p1, const Vertex<3, fltp08>& p2,
        /* returned data */
        Vertex<3, fltp08>& arc_mid,
        Vertex<3, fltp08>& arc_center,
        fltp08& radius,
        double* chord,
        double* chordMidX, double* chordMidY,
        double* sagitta, double* apothem,
        Angle<fltp08>& span)
    {
        Angle<fltp08> chordAngleInRadians;
        Angle<fltp08> sagittaAngleInRadians;
 
        double w, h, fx, fy, dx, dy;
        bool clockwise = bulge < 0.0;
 
        /* Calculate the Included Angle in Radians */
        span = Angle<fltp08>::atan(bulge) * 4.0;
 
        /* Calculate the Chord */
        w = fabs(p1[X] - p2[X]);
        h = fabs(p1[Y] - p2[Y]);
        *chord = sqrt(w * w + h * h);
 
        /* Calculate the Radius */
        radius = fabs(*chord / (2.0 * sin(span / 2.0)));
 
 
        /* Calculate the Sagitta */
        *sagitta = fabs((*chord / 2.0) * bulge);
 
        /* Calculate the Apothem */
        *apothem = fabs(radius - *sagitta);
 
        /* Calculate the Chord MidPoint */
        *chordMidX = (p1[X] + p2[X]) / 2.0;
        *chordMidY = (p1[Y] + p2[Y]) / 2.0;
 
        /* Calculate the Chord Angle (from arcStart to arcEnd) */
        dx = p1[X] - p1[X];
        dy = p2[Y] - p1[Y];
        chordAngleInRadians = Angle<fltp08>::atan2(dy, dx);
 
        /* Calculate the Sagitta Angle (from chordMid to arcMid) */
        if (clockwise) sagittaAngleInRadians = chordAngleInRadians + Angle<fltp08>(DEGREES, 90.0);
        else           sagittaAngleInRadians = chordAngleInRadians - Angle<fltp08>(DEGREES, 90.0);
 
        /* Calculate the Arc MidPoint */
        fx = *sagitta * cos(sagittaAngleInRadians);
        fy = *sagitta * sin(sagittaAngleInRadians);
        arc_mid[X] = *chordMidX + fx;
        arc_mid[Y] = *chordMidY + fy;
 
        /* Calculate the Arc CenterPoint */
        arc_center = getArcCenter(p1[X], p1[Y], arc_mid[X], arc_mid[Y], p2[X], p2[Y]);
 
 
        /* Confirm the direction of the Arc, it should match the Bulge */
        if (clockwise != isArcClockwise(p1[X], p1[Y], arc_mid[X], arc_mid[Y], p2[X], p2[Y]))
        {
            lib_assert(false, "Arc and Bulge direction do not match.");
            
        }
        if (!clockwise)
            span = -span;
    }
}