/*

 *

 *  Copyright (C) 1996-2018, 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:  dcmimgle

 *

 *  Author:  Joerg Riesmeier

 *

 *  Purpose: DicomMonochromeModality (Source)

 *

 */

#include "dcmtk/config/osconfig.h"

#include "dcmtk/dcmdata/dcdeftag.h"

#include "dcmtk/dcmdata/dcuid.h"

#include "dcmtk/dcmimgle/dimomod.h"

#include "dcmtk/dcmimgle/didocu.h"

#include "dcmtk/dcmimgle/diinpx.h"

/*----------------*

 *  constructors  *

 *----------------*/

DiMonoModality::DiMonoModality(const DiDocument *docu,

                               DiInputPixel *pixel)

  : Representation(EPR_MaxSigned),

    MinValue(0),

    MaxValue(0),

    Bits(0),

    UsedBits(0),

    AbsMinimum(0),

    AbsMaximum(0),

    RescaleIntercept(0),

    RescaleSlope(0),

    LookupTable(0),

    Rescaling(0),

    TableData(NULL)

{

    if (Init(docu, pixel))

    {

        if (docu->getFlags() & CIF_IgnoreModalityTransformation)        // ignore modality LUT and rescaling

        {

            DCMIMGLE_INFO("configuration flag set ... ignoring possible modality transform");

        }

        else if (!(docu->getFlags() & CIF_UsePresentationState))        // ignore modality LUT and rescaling

        {

            const char *sopClassUID = NULL;                             // check for XA and XRF image (ignore MLUT)

            if (!docu->getValue(DCM_SOPClassUID, sopClassUID) || (sopClassUID == NULL))

                sopClassUID = "";

            if ((strcmp(sopClassUID, UID_XRayAngiographicImageStorage) == 0) ||

                (strcmp(sopClassUID, UID_XRayRadiofluoroscopicImageStorage) == 0) ||

                (strcmp(sopClassUID, UID_RETIRED_XRayAngiographicBiPlaneImageStorage) == 0))

            {

                /* David Clunie in comp.protocols.dicom (2000-12-13):

                    "Modality LUTs in XA and XRF objects are totally screwy and

                     do not follow the normal rules. [...] A Modality LUT may be

                     included with the image to allow it to be scaled back to its

                     proportional value to X-Ray beam intensity. In other words,

                     for the objects that use this module (XA and XRF), the

                     Modality LUT is used BACKWARDS. It is used to convert stored

                     pixels to X-Ray beam intensity space, but it is NOT APPLIED

                     to stored pixels for the purpose of display (or more

                     specifically prior to application of the VOI LUT Module

                     attributes to the stored pixel data)."

                */

                DCMIMGLE_INFO("processing XA or XRF image ... ignoring possible modality transform");

            } else {

                EL_BitsPerTableEntry descMode = ELM_UseValue;          // first search on main level

                if (docu->getFlags() & CIF_IgnoreModalityLutBitDepth)

                    descMode = ELM_IgnoreValue;

                else if (docu->getFlags() & CIF_CheckLutBitDepth)

                    descMode = ELM_CheckValue;

                TableData = new DiLookupTable(docu, DCM_ModalityLUTSequence, DCM_LUTDescriptor, DCM_LUTData,

                    DCM_LUTExplanation, descMode);

                checkTable();

                if (LookupTable)

                    DCMIMGLE_DEBUG("found modality LUT on main dataset level");

                Rescaling = (docu->getValue(DCM_RescaleIntercept, RescaleIntercept) > 0);

                Rescaling &= (docu->getValue(DCM_RescaleSlope, RescaleSlope) > 0);

                if (Rescaling)

                    DCMIMGLE_DEBUG("found 'RescaleSlope/Intercept' on main dataset level");

                else if (!LookupTable)                                 // then check for functional groups sequence

                {

                    DcmSequenceOfItems *seq = NULL;

                    if (docu->getSequence(DCM_SharedFunctionalGroupsSequence, seq))

                    {

                        DcmItem *item = seq->getItem(0);

                        if ((item != NULL) && docu->getSequence(DCM_PixelValueTransformationSequence, seq, item))

                        {

                            item = seq->getItem(0);

                            if (item != NULL)

                            {

                                Rescaling = (docu->getValue(DCM_RescaleIntercept, RescaleIntercept, 0, item) > 0);

                                Rescaling &= (docu->getValue(DCM_RescaleSlope, RescaleSlope, 0, item) > 0);

                                if (Rescaling)

                                    DCMIMGLE_DEBUG("found 'RescaleSlope/Intercept' in 'SharedFunctionalGroupsSequence'");

                            }

                        }

                    }

                }

                checkRescaling(pixel);

                if (Rescaling || LookupTable)                          // check for possibly inappropriate use of MLUT

                {

                    /* David Clunie in comp.protocols.dicom (2012-10-28):

                        "By the way, in general, it can be difficult to decide

                         whether or not to apply the conceptual Modality LUT

                         step before windowing, even if it is specified by

                         Rescale Slope/Intercept values rather than an actual

                         LUT. For example, in MR images to which Philips has

                         added the rescale values, these should not be applied

                         before their window values; likewise in PET images,

                         especially those with GML Units and rescale values to

                         SUV (small decimal numbers), the window values are

                         historically usually in stored pixel values rather than

                         SUVs.

                         Making the correct decision may require comparing the

                         range of possible rescaled output values (across the

                         domain of possible input stored pixel values) with the

                         specific window values, to see if the latter "make

                         sense".

                    */

                    if (strcmp(sopClassUID, UID_MRImageStorage) == 0)

                        DCMIMGLE_WARN("processing MR image ... applying modality transform may create unexpected result");

                    else if (strcmp(sopClassUID, UID_PositronEmissionTomographyImageStorage) == 0)

                        DCMIMGLE_WARN("processing PET image ... applying modality transform may create unexpected result");

                    else if (strcmp(sopClassUID, UID_RTDoseStorage) == 0)

                        DCMIMGLE_WARN("processing RTDOSE object ... applying modality transform may create unexpected result");

                }

            }

        }

        determineRepresentation(docu);

    }

}

DiMonoModality::DiMonoModality(const DiDocument *docu,

                               DiInputPixel *pixel,

                               const double slope,

                               const double intercept)

  : Representation(EPR_MaxSigned),

    MinValue(0),

    MaxValue(0),

    Bits(0),

    UsedBits(0),

    AbsMinimum(0),

    AbsMaximum(0),

    RescaleIntercept(intercept),

    RescaleSlope(slope),

    LookupTable(0),

    Rescaling(0),

    TableData(NULL)

{

    if (Init(docu, pixel))

    {

        Rescaling = 1;

        checkRescaling(pixel);

        determineRepresentation(docu);

    }

}

DiMonoModality::DiMonoModality(const DiDocument *docu,

                               DiInputPixel *pixel,

                               const DcmUnsignedShort &data,

                               const DcmUnsignedShort &descriptor,

                               const DcmLongString *explanation)

  : Representation(EPR_MaxSigned),

    MinValue(0),

    MaxValue(0),

    Bits(0),

    UsedBits(0),

    AbsMinimum(0),

    AbsMaximum(0),

    RescaleIntercept(0),

    RescaleSlope(0),

    LookupTable(0),

    Rescaling(0),

    TableData(NULL)

{

    if (Init(docu, pixel))

    {

        EL_BitsPerTableEntry descMode = ELM_UseValue;

        if (docu->getFlags() & CIF_IgnoreModalityLutBitDepth)

            descMode = ELM_IgnoreValue;

        else if (docu->getFlags() & CIF_CheckLutBitDepth)

            descMode = ELM_CheckValue;

        TableData = new DiLookupTable(data, descriptor, explanation, descMode);

        checkTable();

        determineRepresentation(docu);

    }

}

DiMonoModality::DiMonoModality(const int bits)

  : Representation(EPR_MaxSigned),

    MinValue(0),

    MaxValue(0),

    Bits(bits),

    UsedBits(0),

    AbsMinimum(0),

    AbsMaximum(DicomImageClass::maxval(bits)),

    RescaleIntercept(0),

    RescaleSlope(0),

    LookupTable(0),

    Rescaling(0),

    TableData(NULL)

{

}

/*--------------*

 *  destructor  *

 *--------------*/

DiMonoModality::~DiMonoModality()

{

    delete TableData;

}

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

int DiMonoModality::Init(const DiDocument *docu,

                         DiInputPixel *pixel)

{

    if ((docu != NULL) && (pixel != NULL))

    {

        pixel->determineMinMax();

        MinValue = pixel->getMinValue(1 /* selected range of pixels only */);

        MaxValue = pixel->getMaxValue(1 /* selected range of pixels only */);

        Bits = pixel->getBits();

        AbsMinimum = pixel->getAbsMinimum();

        AbsMaximum = pixel->getAbsMaximum();

        Uint16 us;

        if (docu->getValue(DCM_SamplesPerPixel, us) > 0)

        {

            if (us != 1)

                DCMIMGLE_WARN("invalid value for 'SamplesPerPixel' (" << us << ") ... assuming 1");

        } else

            DCMIMGLE_WARN("missing value for 'SamplesPerPixel' ... assuming 1");

        return 1;

    }

    return 0;

}

void DiMonoModality::checkTable()

{

    if (TableData != NULL)

    {

        LookupTable = TableData->isValid();

        if (LookupTable)

        {

            MinValue = TableData->getMinValue();

            MaxValue = TableData->getMaxValue();

            Bits = TableData->getBits();

            AbsMinimum = 0;

            AbsMaximum = DicomImageClass::maxval(Bits);

        }

    }

}

void DiMonoModality::checkRescaling(const DiInputPixel *pixel)

{

    if (Rescaling)

    {

        if (LookupTable)

        {

            DCMIMGLE_WARN("redundant values for 'RescaleSlope/Intercept' ... using modality LUT transformation");

            Rescaling = 0;

        } else {

            if (RescaleSlope == 0)

            {

                DCMIMGLE_WARN("invalid value for 'RescaleSlope' (" << RescaleSlope << ") ... ignoring modality transformation");

                Rescaling = 0;

            } else {

                if (RescaleSlope < 0)                                       // negative slope value

                {

                    const double temp = MinValue;

                    MinValue = MaxValue * RescaleSlope + RescaleIntercept;

                    MaxValue = temp * RescaleSlope + RescaleIntercept;

                    AbsMinimum = pixel->getAbsMaximum() * RescaleSlope + RescaleIntercept;

                    AbsMaximum = pixel->getAbsMinimum() * RescaleSlope + RescaleIntercept;

                } else {                                                    // positive slope value

                    MinValue = MinValue * RescaleSlope + RescaleIntercept;

                    MaxValue = MaxValue * RescaleSlope + RescaleIntercept;

                    AbsMinimum = pixel->getAbsMinimum() * RescaleSlope + RescaleIntercept;

                    AbsMaximum = pixel->getAbsMaximum() * RescaleSlope + RescaleIntercept;

                }

                Bits = DicomImageClass::rangeToBits(AbsMinimum, AbsMaximum);

            }

        }

    }

}

void DiMonoModality::determineRepresentation(const DiDocument *docu)

{

    UsedBits = DicomImageClass::rangeToBits(MinValue, MaxValue);

    if ((docu != NULL) && (docu->getFlags() & CIF_UseAbsolutePixelRange))

        Representation = DicomImageClass::determineRepresentation(AbsMinimum, AbsMaximum);

    else

        Representation = DicomImageClass::determineRepresentation(MinValue, MaxValue);

    DCMIMGLE_TRACE("internal representation for monochrome images: "

        << DicomImageClass::getRepresentationBits(Representation) << " bits ("

        << (DicomImageClass::isRepresentationSigned(Representation) ? "signed" : "unsigned") << ")");

}