/*

 *

 *  Copyright (C) 2013-2026, OFFIS e.V.

 *  All rights reserved.  See COPYRIGHT file for details.

 *

 *  This software and supporting documentation were developed by

 *

 *    OFFIS e.V.

 *    R&D Division Health

 *    Escherweg 2

 *    D-26121 Oldenburg, Germany

 *

 *

 *  Module:  dcmdata

 *

 *  Author:  Joerg Riesmeier

 *

 *  Purpose: Implementation of class DcmOtherDouble

 *

 */

#include "dcmtk/config/osconfig.h"    /* make sure OS specific configuration is included first */

#include "dcmtk/ofstd/ofuuidgn.h"

#include "dcmtk/ofstd/ofstd.h"

#include "dcmtk/ofstd/ofmath.h"

#include "dcmtk/dcmdata/dcvrod.h"

#include "dcmtk/dcmdata/dcswap.h"

#include "dcmtk/dcmdata/dcjson.h"

#include <cmath>

// ********************************

DcmOtherDouble::DcmOtherDouble(const DcmTag &tag,

                               const Uint32 len)

  : DcmFloatingPointDouble(tag, len)

{

}

DcmOtherDouble::DcmOtherDouble(const DcmOtherDouble &old)

  : DcmFloatingPointDouble(old)

{

}

DcmOtherDouble::~DcmOtherDouble()

{

}

DcmOtherDouble &DcmOtherDouble::operator=(const DcmOtherDouble &obj)

{

    DcmFloatingPointDouble::operator=(obj);

    return *this;

}

OFCondition DcmOtherDouble::copyFrom(const DcmObject& rhs)

{

  if (this != &rhs)

  {

    if (rhs.ident() != ident()) return EC_IllegalCall;

    *this = OFstatic_cast(const DcmOtherDouble &, rhs);

  }

  return EC_Normal;

}

// ********************************

DcmEVR DcmOtherDouble::ident() const

{

    return EVR_OD;

}

OFCondition DcmOtherDouble::checkValue(const OFString & /*vm*/,

                                       const OFBool /*oldFormat*/)

{

    /* currently no checks are performed */

    return EC_Normal;

}

unsigned long DcmOtherDouble::getVM()

{

    /* value multiplicity for OD is defined as 1 */

    return 1;

}

// ********************************

/* need to check for "Not a Number" in order to avoid possible output of "-nan" */

static inline void checkAndOutputFloatValue(STD_NAMESPACE ostream &out,

                                            const Float64 value)

{

    if (OFMath::isnan(value))

        out << "nan";

    else

        out << value;

}

OFCondition DcmOtherDouble::writeXML(STD_NAMESPACE ostream &out,

                                    const size_t flags)

{

    OFCondition l_error = EC_Normal;

    /* always write XML start tag */

    writeXMLStartTag(out, flags);

    /* OD data requires special handling in the Native DICOM Model format */

    if (flags & DCMTypes::XF_useNativeModel)

    {

        /* for an empty value field, we do not need to do anything */

        if (getLengthField() > 0)

        {

            /* encode binary data as Base64 */

            if (flags & DCMTypes::XF_encodeBase64)

            {

                out << "<InlineBinary>";

                /* the Native DICOM Model requires little endian byte ordering */

                Uint8 *byteValues = OFstatic_cast(Uint8 *, getValue(EBO_LittleEndian));

                OFStandard::encodeBase64(out, byteValues, OFstatic_cast(size_t, getLengthField()));

                out << "</InlineBinary>" << OFendl;

            } else {

                /* generate a new UID but the binary data is not (yet) written. */

                OFshared_ptr<OFUUID> const uuid = OFUUIDGenerator::create();

                if (uuid) {

                    out << "<BulkData uuid=\"";

                    uuid->print(out, OFUUID::NotationCanonical);

                    out << "\"/>" << OFendl;

                } else {

                    l_error = EC_MemoryExhausted;

                }

            }

        }

    } else {

        /* write element value (if loaded) */

        if (valueLoaded())

        {

            Float64 *floatValues = NULL;

            /* get and check 64 bit float data */

            if (getFloat64Array(floatValues).good() && (floatValues != NULL))

            {

                const size_t count = getNumberOfValues();

                /* count can be zero if we have an invalid element with less than eight bytes length */

                if (count > 0)

                {

                    /* increase default precision - see DcmFloatingPointDouble::print() */

                    const STD_NAMESPACE streamsize oldPrecision = out.precision(17);

                    /* use the standard "C" locale for proper decimal point */

                    const STD_NAMESPACE locale oldLocale = out.imbue(STD_NAMESPACE locale("C"));

                    /* print float values with separators */

                    checkAndOutputFloatValue(out, *(floatValues++));

                    for (unsigned long i = 1; i < count; i++)

                    {

                        out << "\\";

                        checkAndOutputFloatValue(out, *(floatValues++));

                    }

                    /* reset i/o manipulators and locale */

                    out.precision(oldPrecision);

                    out.imbue(oldLocale);

                }

            }

        }

    }

    /* always write XML end tag */

    writeXMLEndTag(out, flags);

    /* always report success */

    return l_error;

}

// ********************************

OFCondition DcmOtherDouble::writeJson(STD_NAMESPACE ostream &out,

                                      DcmJsonFormat &format)

{

    OFCondition result = EC_Normal;

    /* write JSON Opener */

    writeJsonOpener(out, format);

    /* for an empty value field, we do not need to do anything */

    if (getLengthField() > 0)

    {

        /* adjust byte order to little endian */

        Uint8 *byteValues = OFstatic_cast(Uint8 *, getValue(EBO_LittleEndian));

        result = format.writeBinaryAttribute(out, getTag(), getLengthField(), byteValues);

    }

    /* write JSON Closer */

    writeJsonCloser(out, format);

    return result;

}

// ********************************

OFCondition DcmOtherDouble::createFloat64Array(const Uint32 numDoubles,

                                               Float64 *&doubleVals)

{

    Uint32 bytesRequired = 0;

    /* make sure that max length is not exceeded */

    if (OFStandard::safeMult(numDoubles, OFstatic_cast(Uint32, sizeof(Float64)), bytesRequired))

        errorFlag = createEmptyValue(bytesRequired);

    else

        errorFlag = EC_ElemLengthExceeds32BitField;

    if (errorFlag.good())

        doubleVals = OFstatic_cast(Float64 *, this->getValue());

    else

        doubleVals = NULL;

    return errorFlag;

}