/src/gdal/ogr/ogrsf_frmts/cad/ogrcadlayer.cpp

Source
/*******************************************************************************
 *  Project: OGR CAD Driver
 *  Purpose: Implements driver based on libopencad
 *  Author: Alexandr Borzykh, mush3d at gmail.com
 *  Author: Dmitry Baryshnikov, polimax@mail.ru
 *  Language: C++
 *******************************************************************************
 *  The MIT License (MIT)
 *
 *  Copyright (c) 2016 Alexandr Borzykh
 *  Copyright (c) 2016-2019, NextGIS <info@nextgis.com>
 *
 * SPDX-License-Identifier: MIT
 *******************************************************************************/
#include "cpl_conv.h"
#include "ogr_cad.h"

#include <algorithm>
#include <iomanip>
#include <sstream>

#define FIELD_NAME_GEOMTYPE "cadgeom_type"
#define FIELD_NAME_THICKNESS "thickness"
#define FIELD_NAME_COLOR "color"
#define FIELD_NAME_EXT_DATA "extentity_data"
#define FIELD_NAME_TEXT "text"

constexpr double DEG2RAD = M_PI / 180.0;
constexpr double RAD2DEG = 1.0 / DEG2RAD;

OGRCADLayer::OGRCADLayer(GDALDataset *poDS, CADLayer &poCADLayer_,
                         OGRSpatialReference *poSR, int nEncoding)
    : m_poDS(poDS), poSpatialRef(poSR), poCADLayer(poCADLayer_),
      nDWGEncoding(nEncoding)
{
    nNextFID = 0;

    if (poSpatialRef)
        poSpatialRef->Reference();
    poFeatureDefn =
        new OGRFeatureDefn(CADRecode(poCADLayer_.getName(), nDWGEncoding));

    // Setting up layer geometry type
    OGRwkbGeometryType eGeomType;
    char dLineStringPresented = 0;
    char dCircularStringPresented = 0;
    char dPointPresented = 0;
    char dPolygonPresented = 0;
    std::vector<CADObject::ObjectType> aePresentedGeometryTypes =
        poCADLayer.getGeometryTypes();
    for (size_t i = 0; i < aePresentedGeometryTypes.size(); ++i)
    {
        switch (aePresentedGeometryTypes[i])
        {
            case CADObject::ATTDEF:
            case CADObject::TEXT:
            case CADObject::MTEXT:
            case CADObject::POINT:
                dPointPresented = 1;
                break;
            case CADObject::CIRCLE:
                dCircularStringPresented = 1;
                break;
            case CADObject::SPLINE:
            case CADObject::ELLIPSE:
            case CADObject::ARC:
            case CADObject::POLYLINE3D:
            case CADObject::POLYLINE2D:
            case CADObject::LWPOLYLINE:
            case CADObject::LINE:
                dLineStringPresented = 1;
                break;
            case CADObject::FACE3D:
            case CADObject::SOLID:
                dPolygonPresented = 1;
                break;
            default:
                break;
        }
    }

    if ((dLineStringPresented + dCircularStringPresented + dPointPresented +
         dPolygonPresented) > 1)
    {
        eGeomType = wkbGeometryCollection;
    }
    else
    {
        if (dLineStringPresented)
        {
            eGeomType = wkbLineString;
        }
        else if (dCircularStringPresented)
        {
            eGeomType = wkbCircularString;
        }
        else if (dPointPresented)
        {
            eGeomType = wkbPoint;
        }
        else if (dPolygonPresented)
        {
            eGeomType = wkbPolygon;
        }
        else
        {
            eGeomType = wkbUnknown;
        }
    }
    poFeatureDefn->SetGeomType(eGeomType);

    OGRFieldDefn oClassField(FIELD_NAME_GEOMTYPE, OFTString);
    poFeatureDefn->AddFieldDefn(&oClassField);

    OGRFieldDefn oLinetypeField(FIELD_NAME_THICKNESS, OFTReal);
    poFeatureDefn->AddFieldDefn(&oLinetypeField);

    OGRFieldDefn oColorField(FIELD_NAME_COLOR, OFTString);
    poFeatureDefn->AddFieldDefn(&oColorField);

    OGRFieldDefn oExtendedField(FIELD_NAME_EXT_DATA, OFTString);
    poFeatureDefn->AddFieldDefn(&oExtendedField);

    OGRFieldDefn oTextField(FIELD_NAME_TEXT, OFTString);
    poFeatureDefn->AddFieldDefn(&oTextField);

    auto oAttrTags = poCADLayer.getAttributesTags();
    for (const std::string &osTag : oAttrTags)
    {
        auto ret = asFeaturesAttributes.insert(osTag);
        if (ret.second == true)
        {
            OGRFieldDefn oAttrField(osTag.c_str(), OFTString);
            poFeatureDefn->AddFieldDefn(&oAttrField);
        }
    }

    // Applying spatial ref info
    if (poFeatureDefn->GetGeomFieldCount() != 0)
        poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSpatialRef);

    SetDescription(poFeatureDefn->GetName());
    poFeatureDefn->Reference();
}

GIntBig OGRCADLayer::GetFeatureCount(int bForce)
{
    if (m_poFilterGeom != nullptr || m_poAttrQuery != nullptr)
        return OGRLayer::GetFeatureCount(bForce);

    return poCADLayer.getGeometryCount();
}

int OGRCADLayer::TestCapability(const char *pszCap) const
{
    if (EQUAL(pszCap, OLCMeasuredGeometries))
        return true;
    if (EQUAL(pszCap, OLCZGeometries))
        return true;
    if (EQUAL(pszCap, OLCCurveGeometries))
        return true;

    return FALSE;
}

OGRCADLayer::~OGRCADLayer()
{
    if (poSpatialRef)
        poSpatialRef->Release();
    poFeatureDefn->Release();
}

void OGRCADLayer::ResetReading()
{
    nNextFID = 0;
}

OGRFeature *OGRCADLayer::GetNextFeature()
{
    OGRFeature *poFeature = GetFeature(nNextFID);
    ++nNextFID;

    if (poFeature == nullptr)
        return nullptr;

    if ((m_poFilterGeom == nullptr ||
         FilterGeometry(poFeature->GetGeometryRef())) &&
        (m_poAttrQuery == nullptr || m_poAttrQuery->Evaluate(poFeature)))
    {
        return poFeature;
    }

    return nullptr;
}

OGRFeature *OGRCADLayer::GetFeature(GIntBig nFID)
{
    if (poCADLayer.getGeometryCount() <= static_cast<size_t>(nFID) || nFID < 0)
    {
        return nullptr;
    }

    OGRFeature *poFeature = nullptr;
    CADGeometry *poCADGeometry =
        poCADLayer.getGeometry(static_cast<size_t>(nFID));

    if (nullptr == poCADGeometry ||
        GetLastErrorCode() != CADErrorCodes::SUCCESS)
    {
        CPLError(CE_Failure, CPLE_NotSupported,
                 "Failed to get geometry with ID = " CPL_FRMT_GIB
                 " from layer \"%s\". Libopencad errorcode: %d",
                 nFID, poCADLayer.getName().c_str(), GetLastErrorCode());
        return nullptr;
    }

    poFeature = new OGRFeature(poFeatureDefn);
    poFeature->SetFID(nFID);
    poFeature->SetField(FIELD_NAME_THICKNESS, poCADGeometry->getThickness());

    if (!poCADGeometry->getEED().empty())
    {
        std::vector<std::string> asGeometryEED = poCADGeometry->getEED();
        std::string sEEDAsOneString = "";
        for (std::vector<std::string>::const_iterator iter =
                 asGeometryEED.cbegin();
             iter != asGeometryEED.cend(); ++iter)
        {
            sEEDAsOneString += *iter;
            sEEDAsOneString += ' ';
        }

        poFeature->SetField(FIELD_NAME_EXT_DATA, sEEDAsOneString.c_str());
    }

    RGBColor stRGB = poCADGeometry->getColor();
    CPLString sHexColor;
    sHexColor.Printf("#%02X%02X%02X%02X", stRGB.R, stRGB.G, stRGB.B, 255);
    poFeature->SetField(FIELD_NAME_COLOR, sHexColor);

    CPLString sStyle;
    sStyle.Printf("PEN(c:%s,w:5px)", sHexColor.c_str());
    poFeature->SetStyleString(sStyle);

    std::vector<CADAttrib> oBlockAttrs = poCADGeometry->getBlockAttributes();
    for (const CADAttrib &oAttrib : oBlockAttrs)
    {
        CPLString osTag = oAttrib.getTag();
        auto featureAttrIt = asFeaturesAttributes.find(osTag);
        if (featureAttrIt != asFeaturesAttributes.end())
        {
            poFeature->SetField(*featureAttrIt, oAttrib.getTextValue().c_str());
        }
    }

    switch (poCADGeometry->getType())
    {
        case CADGeometry::POINT:
        {
            CADPoint3D *const poCADPoint =
                cpl::down_cast<CADPoint3D *>(poCADGeometry);
            CADVector stPositionVector = poCADPoint->getPosition();

            poFeature->SetGeometryDirectly(
                new OGRPoint(stPositionVector.getX(), stPositionVector.getY(),
                             stPositionVector.getZ()));
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADPoint");
            break;
        }

        case CADGeometry::LINE:
        {
            CADLine *const poCADLine = cpl::down_cast<CADLine *>(poCADGeometry);
            OGRLineString *poLS = new OGRLineString();
            poLS->addPoint(poCADLine->getStart().getPosition().getX(),
                           poCADLine->getStart().getPosition().getY(),
                           poCADLine->getStart().getPosition().getZ());
            poLS->addPoint(poCADLine->getEnd().getPosition().getX(),
                           poCADLine->getEnd().getPosition().getY(),
                           poCADLine->getEnd().getPosition().getZ());

            poFeature->SetGeometryDirectly(poLS);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADLine");
            break;
        }

        case CADGeometry::SOLID:
        {
            CADSolid *const poCADSolid =
                cpl::down_cast<CADSolid *>(poCADGeometry);
            OGRPolygon *poPoly = new OGRPolygon();
            OGRLinearRing *poLR = new OGRLinearRing();

            std::vector<CADVector> astSolidCorners = poCADSolid->getCorners();
            for (size_t i = 0; i < astSolidCorners.size(); ++i)
            {
                poLR->addPoint(astSolidCorners[i].getX(),
                               astSolidCorners[i].getY(),
                               astSolidCorners[i].getZ());
            }
            poPoly->addRingDirectly(poLR);
            poPoly->closeRings();
            poFeature->SetGeometryDirectly(poPoly);

            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADSolid");
            break;
        }

        case CADGeometry::CIRCLE:
        {
            CADCircle *poCADCircle = cpl::down_cast<CADCircle *>(poCADGeometry);
            OGRCircularString *poCircle = new OGRCircularString();

            CADVector stCircleCenter = poCADCircle->getPosition();
            OGRPoint oCirclePoint1;
            oCirclePoint1.setX(stCircleCenter.getX() -
                               poCADCircle->getRadius());
            oCirclePoint1.setY(stCircleCenter.getY());
            oCirclePoint1.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint1);

            OGRPoint oCirclePoint2;
            oCirclePoint2.setX(stCircleCenter.getX());
            oCirclePoint2.setY(stCircleCenter.getY() +
                               poCADCircle->getRadius());
            oCirclePoint2.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint2);

            OGRPoint oCirclePoint3;
            oCirclePoint3.setX(stCircleCenter.getX() +
                               poCADCircle->getRadius());
            oCirclePoint3.setY(stCircleCenter.getY());
            oCirclePoint3.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint3);

            OGRPoint oCirclePoint4;
            oCirclePoint4.setX(stCircleCenter.getX());
            oCirclePoint4.setY(stCircleCenter.getY() -
                               poCADCircle->getRadius());
            oCirclePoint4.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint4);

            // Close the circle
            poCircle->addPoint(&oCirclePoint1);

            /*NOTE: The alternative way:
                    OGRGeometry *poCircle =
               OGRGeometryFactory::approximateArcAngles(
                    poCADCircle->getPosition().getX(),
                    poCADCircle->getPosition().getY(),
                    poCADCircle->getPosition().getZ(),
                    poCADCircle->getRadius(), poCADCircle->getRadius(), 0.0,
                    0.0, 360.0,
                    0.0 );
            */
            poFeature->SetGeometryDirectly(poCircle);

            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADCircle");
            break;
        }

        case CADGeometry::ARC:
        {
            CADArc *poCADArc = cpl::down_cast<CADArc *>(poCADGeometry);
            OGRCircularString *poCircle = new OGRCircularString();

            // Need at least 3 points in arc
            double dfStartAngle = poCADArc->getStartingAngle() * RAD2DEG;
            double dfEndAngle = poCADArc->getEndingAngle() * RAD2DEG;
            double dfMidAngle = (dfEndAngle + dfStartAngle) / 2;
            CADVector stCircleCenter = poCADArc->getPosition();

            OGRPoint oCirclePoint;
            oCirclePoint.setX(stCircleCenter.getX() +
                              poCADArc->getRadius() * cos(dfStartAngle));
            oCirclePoint.setY(stCircleCenter.getY() +
                              poCADArc->getRadius() * sin(dfStartAngle));
            oCirclePoint.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint);

            oCirclePoint.setX(stCircleCenter.getX() +
                              poCADArc->getRadius() * cos(dfMidAngle));
            oCirclePoint.setY(stCircleCenter.getY() +
                              poCADArc->getRadius() * sin(dfMidAngle));
            oCirclePoint.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint);

            oCirclePoint.setX(stCircleCenter.getX() +
                              poCADArc->getRadius() * cos(dfEndAngle));
            oCirclePoint.setY(stCircleCenter.getY() +
                              poCADArc->getRadius() * sin(dfEndAngle));
            oCirclePoint.setZ(stCircleCenter.getZ());
            poCircle->addPoint(&oCirclePoint);

            /*NOTE: alternative way:
                OGRGeometry * poArc = OGRGeometryFactory::approximateArcAngles(
                poCADArc->getPosition().getX(),
                poCADArc->getPosition().getY(),
                poCADArc->getPosition().getZ(),
                poCADArc->getRadius(), poCADArc->getRadius(), 0.0,
                dfStartAngle,
                dfStartAngle > dfEndAngle ?
                    ( dfEndAngle + 360.0f ) :
                    dfEndAngle,
                0.0 );
            */

            poFeature->SetGeometryDirectly(poCircle);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADArc");

            break;
        }

        case CADGeometry::FACE3D:
        {
            CADFace3D *const poCADFace =
                cpl::down_cast<CADFace3D *>(poCADGeometry);
            OGRPolygon *poPoly = new OGRPolygon();
            OGRLinearRing *poLR = new OGRLinearRing();

            for (size_t i = 0; i < 3; ++i)
            {
                poLR->addPoint(poCADFace->getCorner(i).getX(),
                               poCADFace->getCorner(i).getY(),
                               poCADFace->getCorner(i).getZ());
            }
            if (!(poCADFace->getCorner(2) == poCADFace->getCorner(3)))
            {
                poLR->addPoint(poCADFace->getCorner(3).getX(),
                               poCADFace->getCorner(3).getY(),
                               poCADFace->getCorner(3).getZ());
            }
            poPoly->addRingDirectly(poLR);
            poPoly->closeRings();
            poFeature->SetGeometryDirectly(poPoly);

            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADFace3D");
            break;
        }

        case CADGeometry::LWPOLYLINE:
        {
            CADLWPolyline *const poCADLWPolyline =
                cpl::down_cast<CADLWPolyline *>(poCADGeometry);

            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADLWPolyline");

            /*
             * Excessive check, like in DXF driver.
             * I tried to make a single-point polyline, but couldn't make it.
             * Probably this check should be removed.
             */
            if (poCADLWPolyline->getVertexCount() == 1)
            {
                poFeature->SetGeometryDirectly(
                    new OGRPoint(poCADLWPolyline->getVertex(0).getX(),
                                 poCADLWPolyline->getVertex(0).getY(),
                                 poCADLWPolyline->getVertex(0).getZ()));

                break;
            }

            /*
             * If polyline has no arcs, handle it in easy way.
             */
            OGRLineString *poLS = new OGRLineString();

            if (poCADLWPolyline->getBulges().empty())
            {
                for (size_t i = 0; i < poCADLWPolyline->getVertexCount(); ++i)
                {
                    CADVector stVertex = poCADLWPolyline->getVertex(i);
                    poLS->addPoint(stVertex.getX(), stVertex.getY(),
                                   stVertex.getZ());
                }

                poFeature->SetGeometryDirectly(poLS);
                break;
            }

            /*
             * Last case - if polyline has mixed arcs and lines.
             */
            bool bLineStringStarted = false;
            std::vector<double> adfBulges = poCADLWPolyline->getBulges();
            const size_t nCount =
                std::min(adfBulges.size(), poCADLWPolyline->getVertexCount());

            for (size_t iCurrentVertex = 0; iCurrentVertex + 1 < nCount;
                 iCurrentVertex++)
            {
                CADVector stCurrentVertex =
                    poCADLWPolyline->getVertex(iCurrentVertex);
                CADVector stNextVertex =
                    poCADLWPolyline->getVertex(iCurrentVertex + 1);

                double dfLength =
                    sqrt(pow(stNextVertex.getX() - stCurrentVertex.getX(), 2) +
                         pow(stNextVertex.getY() - stCurrentVertex.getY(), 2));

                /*
                 * Handling straight polyline segment.
                 */
                if ((dfLength == 0) || (adfBulges[iCurrentVertex] == 0))
                {
                    if (!bLineStringStarted)
                    {
                        poLS->addPoint(stCurrentVertex.getX(),
                                       stCurrentVertex.getY(),
                                       stCurrentVertex.getZ());
                        bLineStringStarted = true;
                    }

                    poLS->addPoint(stNextVertex.getX(), stNextVertex.getY(),
                                   stNextVertex.getZ());
                }
                else
                {
                    double dfSegmentBulge = adfBulges[iCurrentVertex];
                    double dfH = (dfSegmentBulge * dfLength) / 2;
                    if (dfH == 0.0)
                        dfH = 1.0;  // just to avoid a division by zero
                    double dfRadius =
                        (dfH / 2) + (dfLength * dfLength / (8 * dfH));
                    double dfOgrArcRotation = 0,
                           dfOgrArcRadius = fabs(dfRadius);

                    /*
                     * Set arc's direction and keep bulge positive.
                     */
                    bool bClockwise = (dfSegmentBulge < 0);
                    if (bClockwise)
                        dfSegmentBulge *= -1;

                    /*
                     * Get arc's center point.
                     */
                    double dfSaggita = fabs(dfSegmentBulge * (dfLength / 2.0));
                    double dfApo = bClockwise ? -(dfOgrArcRadius - dfSaggita)
                                              : -(dfSaggita - dfOgrArcRadius);

                    CADVector stVertex;
                    stVertex.setX(stCurrentVertex.getX() - stNextVertex.getX());
                    stVertex.setY(stCurrentVertex.getY() - stNextVertex.getY());
                    stVertex.setZ(stCurrentVertex.getZ());

                    CADVector stMidPoint;
                    stMidPoint.setX(stNextVertex.getX() +
                                    0.5 * stVertex.getX());
                    stMidPoint.setY(stNextVertex.getY() +
                                    0.5 * stVertex.getY());
                    stMidPoint.setZ(stVertex.getZ());

                    CADVector stPperp;
                    stPperp.setX(stVertex.getY());
                    stPperp.setY(-stVertex.getX());
                    double dfStPperpLength =
                        sqrt(stPperp.getX() * stPperp.getX() +
                             stPperp.getY() * stPperp.getY());
                    // TODO: Check that length isnot 0
                    stPperp.setX(stPperp.getX() / dfStPperpLength);
                    stPperp.setY(stPperp.getY() / dfStPperpLength);

                    CADVector stOgrArcCenter;
                    stOgrArcCenter.setX(stMidPoint.getX() +
                                        (stPperp.getX() * dfApo));
                    stOgrArcCenter.setY(stMidPoint.getY() +
                                        (stPperp.getY() * dfApo));

                    /*
                     * Get the line's general vertical direction ( -1 = down, +1
                     * = up ).
                     */
                    double dfLineDir =
                        stNextVertex.getY() > stCurrentVertex.getY() ? 1.0f
                                                                     : -1.0f;

                    /*
                     * Get arc's starting angle.
                     */
                    double dfA =
                        atan2(
                            (stOgrArcCenter.getY() - stCurrentVertex.getY()),
                            (stOgrArcCenter.getX() - stCurrentVertex.getX())) *
                        RAD2DEG;
                    if (bClockwise && (dfLineDir == 1.0))
                        dfA += (dfLineDir * 180.0);

                    double dfOgrArcStartAngle =
                        dfA > 0.0 ? -(dfA - 180.0) : -(dfA + 180.0);

                    /*
                     * Get arc's ending angle.
                     */
                    dfA = atan2((stOgrArcCenter.getY() - stNextVertex.getY()),
                                (stOgrArcCenter.getX() - stNextVertex.getX())) *
                          RAD2DEG;
                    if (bClockwise && (dfLineDir == 1.0))
                        dfA += (dfLineDir * 180.0);

                    double dfOgrArcEndAngle =
                        dfA > 0.0 ? -(dfA - 180.0) : -(dfA + 180.0);

                    if (!bClockwise && (dfOgrArcStartAngle < dfOgrArcEndAngle))
                        dfOgrArcEndAngle = -180.0 + (dfLineDir * dfA);

                    if (bClockwise && (dfOgrArcStartAngle > dfOgrArcEndAngle))
                        dfOgrArcEndAngle += 360.0;

                    /*
                     * Flip arc's rotation if necessary.
                     */
                    if (bClockwise && (dfLineDir == 1.0))
                        dfOgrArcRotation = dfLineDir * 180.0;

                    /*
                     * Tessellate the arc segment and append to the linestring.
                     */
                    OGRLineString *poArcpoLS =
                        OGRGeometryFactory::approximateArcAngles(
                            stOgrArcCenter.getX(), stOgrArcCenter.getY(),
                            stOgrArcCenter.getZ(), dfOgrArcRadius,
                            dfOgrArcRadius, dfOgrArcRotation,
                            dfOgrArcStartAngle, dfOgrArcEndAngle, 0.0)
                            ->toLineString();

                    poLS->addSubLineString(poArcpoLS);

                    delete (poArcpoLS);
                }
            }

            if (poCADLWPolyline->isClosed())
            {
                poLS->addPoint(poCADLWPolyline->getVertex(0).getX(),
                               poCADLWPolyline->getVertex(0).getY(),
                               poCADLWPolyline->getVertex(0).getZ());
            }

            poFeature->SetGeometryDirectly(poLS);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADLWPolyline");
            break;
        }

        // TODO: Unsupported smooth lines
        case CADGeometry::POLYLINE3D:
        {
            CADPolyline3D *const poCADPolyline3D =
                cpl::down_cast<CADPolyline3D *>(poCADGeometry);
            OGRLineString *poLS = new OGRLineString();

            for (size_t i = 0; i < poCADPolyline3D->getVertexCount(); ++i)
            {
                CADVector stVertex = poCADPolyline3D->getVertex(i);

                poLS->addPoint(stVertex.getX(), stVertex.getY(),
                               stVertex.getZ());
            }

            poFeature->SetGeometryDirectly(poLS);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADPolyline3D");
            break;
        }

        case CADGeometry::TEXT:
        {
            CADText *const poCADText = cpl::down_cast<CADText *>(poCADGeometry);
            OGRPoint *poPoint = new OGRPoint(poCADText->getPosition().getX(),
                                             poCADText->getPosition().getY(),
                                             poCADText->getPosition().getZ());
            CPLString sTextValue =
                CADRecode(poCADText->getTextValue(), nDWGEncoding);

            poFeature->SetField(FIELD_NAME_TEXT, sTextValue);
            poFeature->SetGeometryDirectly(poPoint);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADText");

            sStyle.Printf("LABEL(f:\"Arial\",t:\"%s\",c:%s)",
                          sTextValue.c_str(), sHexColor.c_str());
            poFeature->SetStyleString(sStyle);
            break;
        }

        case CADGeometry::MTEXT:
        {
            CADMText *const poCADMText =
                cpl::down_cast<CADMText *>(poCADGeometry);
            OGRPoint *poPoint = new OGRPoint(poCADMText->getPosition().getX(),
                                             poCADMText->getPosition().getY(),
                                             poCADMText->getPosition().getZ());
            CPLString sTextValue =
                CADRecode(poCADMText->getTextValue(), nDWGEncoding);

            poFeature->SetField(FIELD_NAME_TEXT, sTextValue);
            poFeature->SetGeometryDirectly(poPoint);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADMText");

            sStyle.Printf("LABEL(f:\"Arial\",t:\"%s\",c:%s)",
                          sTextValue.c_str(), sHexColor.c_str());
            poFeature->SetStyleString(sStyle);
            break;
        }

        case CADGeometry::SPLINE:
        {
            CADSpline *const poCADSpline =
                cpl::down_cast<CADSpline *>(poCADGeometry);
            OGRLineString *poLS = new OGRLineString();

            // TODO: Interpolate spline as points or curves
            for (size_t i = 0; i < poCADSpline->getControlPoints().size(); ++i)
            {
                poLS->addPoint(poCADSpline->getControlPoints()[i].getX(),
                               poCADSpline->getControlPoints()[i].getY(),
                               poCADSpline->getControlPoints()[i].getZ());
            }

            poFeature->SetGeometryDirectly(poLS);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADSpline");
            break;
        }

        case CADGeometry::ELLIPSE:
        {
            CADEllipse *poCADEllipse =
                cpl::down_cast<CADEllipse *>(poCADGeometry);

            // FIXME: Start/end angles should be swapped to work exactly as DXF
            // driver. is it correct?
            double dfStartAngle = poCADEllipse->getStartingAngle() * RAD2DEG;
            double dfEndAngle = poCADEllipse->getEndingAngle() * RAD2DEG;
            if (dfStartAngle > dfEndAngle)
            {
                dfEndAngle += 360.0;
            }
            double dfAxisRatio = poCADEllipse->getAxisRatio();

            CADVector stEllipseCenter = poCADEllipse->getPosition();
            CADVector vectSMAxis = poCADEllipse->getSMAxis();
            double dfPrimaryRadius, dfSecondaryRadius;
            double dfRotation;
            dfPrimaryRadius = sqrt(vectSMAxis.getX() * vectSMAxis.getX() +
                                   vectSMAxis.getY() * vectSMAxis.getY() +
                                   vectSMAxis.getZ() * vectSMAxis.getZ());

            dfSecondaryRadius = dfAxisRatio * dfPrimaryRadius;

            dfRotation =
                -1 * atan2(vectSMAxis.getY(), vectSMAxis.getX()) * RAD2DEG;
            /* NOTE: alternative way:
            OGRCircularString * poEllipse = new OGRCircularString();
            OGRPoint  oEllipsePoint1;
            oEllipsePoint1.setX( stEllipseCenter.getX() - dfPrimaryRadius *
                                                            cos( dfRotation ) );
            oEllipsePoint1.setY( stEllipseCenter.getY() + dfPrimaryRadius *
                                                            sin( dfRotation ) );
            oEllipsePoint1.setZ( stEllipseCenter.getZ() );
            poEllipse->addPoint( &oEllipsePoint1 );

            OGRPoint  oEllipsePoint2;
            oEllipsePoint2.setX( stEllipseCenter.getX() + dfSecondaryRadius *
                                                            cos( dfRotation ) );
            oEllipsePoint2.setY( stEllipseCenter.getY() + dfSecondaryRadius *
                                                            sin( dfRotation ) );
            oEllipsePoint2.setZ( stEllipseCenter.getZ() );
            poEllipse->addPoint( &oEllipsePoint2 );

            OGRPoint  oEllipsePoint3;
            oEllipsePoint3.setX( stEllipseCenter.getX() + dfPrimaryRadius *
                                                            cos( dfRotation ) );
            oEllipsePoint3.setY( stEllipseCenter.getY() - dfPrimaryRadius *
                                                            sin( dfRotation ) );
            oEllipsePoint3.setZ( stEllipseCenter.getZ() );
            poEllipse->addPoint( &oEllipsePoint3 );

            OGRPoint  oEllipsePoint4;
            oEllipsePoint4.setX( stEllipseCenter.getX() - dfSecondaryRadius *
                                                            cos( dfRotation ) );
            oEllipsePoint4.setY( stEllipseCenter.getY() - dfSecondaryRadius *
                                                            sin( dfRotation ) );
            oEllipsePoint4.setZ( stEllipseCenter.getZ() );
            poEllipse->addPoint( &oEllipsePoint4 );

            // Close the ellipse
            poEllipse->addPoint( &oEllipsePoint1 );
            */

            CPLDebug("CAD",
                     "Position: %f, %f, %f, radius %f/%f, start angle: %f, end "
                     "angle: %f, rotation: %f",
                     stEllipseCenter.getX(), stEllipseCenter.getY(),
                     stEllipseCenter.getZ(), dfPrimaryRadius, dfSecondaryRadius,
                     dfStartAngle, dfEndAngle, dfRotation);
            OGRGeometry *poEllipse = OGRGeometryFactory::approximateArcAngles(
                stEllipseCenter.getX(), stEllipseCenter.getY(),
                stEllipseCenter.getZ(), dfPrimaryRadius, dfSecondaryRadius,
                dfRotation, dfStartAngle, dfEndAngle, 0.0);

            poFeature->SetGeometryDirectly(poEllipse);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADEllipse");
            break;
        }

        case CADGeometry::ATTDEF:
        {
            CADAttdef *const poCADAttdef =
                cpl::down_cast<CADAttdef *>(poCADGeometry);
            OGRPoint *poPoint = new OGRPoint(poCADAttdef->getPosition().getX(),
                                             poCADAttdef->getPosition().getY(),
                                             poCADAttdef->getPosition().getZ());
            CPLString sTextValue =
                CADRecode(poCADAttdef->getTag(), nDWGEncoding);

            poFeature->SetField(FIELD_NAME_TEXT, sTextValue);
            poFeature->SetGeometryDirectly(poPoint);
            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADAttdef");

            sStyle.Printf("LABEL(f:\"Arial\",t:\"%s\",c:%s)",
                          sTextValue.c_str(), sHexColor.c_str());
            poFeature->SetStyleString(sStyle);
            break;
        }

        default:
        {
            CPLError(CE_Warning, CPLE_NotSupported,
                     "Unhandled feature. Skipping it.");

            poFeature->SetField(FIELD_NAME_GEOMTYPE, "CADUnknown");
            delete poCADGeometry;
            return poFeature;
        }
    }

    delete poCADGeometry;
    poFeature->GetGeometryRef()->assignSpatialReference(poSpatialRef);
    return poFeature;
}

Coverage Report

Created: 2026-06-30 08:33