ContinuousProperty.h

/*-----------------------------------------------------------------------
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"; you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-----------------------------------------------------------------------*/
#pragma once

#include "resqml2/AbstractValuesProperty.h"
#include "common/AbstractHdfProxy.h"

#include <stdexcept>
#include <sstream>      // std::ostringstream

namespace RESQML2_0_1_NS
{
    class DLL_IMPORT_OR_EXPORT ContinuousProperty : public RESQML2_NS::AbstractValuesProperty
    {
    protected:

        ContinuousProperty() {}

    private:

        void init(RESQML2_NS::AbstractRepresentation * rep, const std::string & guid, const std::string & title,
            const unsigned int & dimension, const gsoap_resqml2_0_1::resqml2__IndexableElements & attachmentKind);

    public:

        ContinuousProperty(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject) : RESQML2_NS::AbstractValuesProperty(partialObject) {}

        ContinuousProperty(RESQML2_NS::AbstractRepresentation * rep, const std::string & guid, const std::string & title,
            const unsigned int & dimension, const gsoap_resqml2_0_1::resqml2__IndexableElements & attachmentKind, const gsoap_resqml2_0_1::resqml2__ResqmlUom & uom, const gsoap_resqml2_0_1::resqml2__ResqmlPropertyKind & energisticsPropertyKind);

        ContinuousProperty(RESQML2_NS::AbstractRepresentation * rep, const std::string & guid, const std::string & title,
            const unsigned int & dimension, const gsoap_resqml2_0_1::resqml2__IndexableElements & attachmentKind, const gsoap_resqml2_0_1::resqml2__ResqmlUom & uom, RESQML2_NS::PropertyKind * localPropKind);

        ContinuousProperty(RESQML2_NS::AbstractRepresentation * rep, const std::string & guid, const std::string & title,
            const unsigned int & dimension, const gsoap_resqml2_0_1::resqml2__IndexableElements & attachmentKind, const std::string & nonStandardUom, const gsoap_resqml2_0_1::resqml2__ResqmlPropertyKind & energisticsPropertyKind);

        ContinuousProperty(RESQML2_NS::AbstractRepresentation * rep, const std::string & guid, const std::string & title,
            const unsigned int & dimension, const gsoap_resqml2_0_1::resqml2__IndexableElements & attachmentKind, const std::string & nonStandardUom, RESQML2_NS::PropertyKind * localPropKind);

        ContinuousProperty(gsoap_resqml2_0_1::_resqml2__ContinuousProperty* fromGsoap): AbstractValuesProperty(fromGsoap) {}

        virtual ~ContinuousProperty() {}

        static const char* XML_TAG;
        virtual std::string getXmlTag() const {return XML_TAG;}

        const gsoap_resqml2_0_1::resqml2__ResqmlUom & getUom() const;

        std::string getUomAsString() const;

        void pushBackDoubleHdf5Array1dOfValues(double * values, const ULONG64 & valueCount, COMMON_NS::AbstractHdfProxy* proxy,
            const double & minimumValue = std::numeric_limits<double>::quiet_NaN(), const double & maximumValue = std::numeric_limits<double>::quiet_NaN());

        void pushBackDoubleHdf5Array2dOfValues(double * values, const ULONG64 & valueCountInFastestDim, const ULONG64 & valueCountInSlowestDim, COMMON_NS::AbstractHdfProxy* proxy,
            const double & minimumValue = std::numeric_limits<double>::quiet_NaN(), const double & maximumValue = std::numeric_limits<double>::quiet_NaN());

        void pushBackDoubleHdf5Array3dOfValues(double * values, const ULONG64 & valueCountInFastestDim, const ULONG64 & valueCountInMiddleDim, const ULONG64 & valueCountInSlowestDim, COMMON_NS::AbstractHdfProxy* proxy,
            const double & minimumValue = std::numeric_limits<double>::quiet_NaN(), const double & maximumValue = std::numeric_limits<double>::quiet_NaN());

        void pushBackDoubleHdf5ArrayOfValues(double * values, unsigned long long * numValues, const unsigned int & numArrayDimensions, COMMON_NS::AbstractHdfProxy* proxy,
            double * minimumValue = nullptr, double * maximumValue = nullptr);

        void pushBackFloatHdf5Array1dOfValues(float * values, const ULONG64 & valueCount, COMMON_NS::AbstractHdfProxy* proxy,
            const float & minimumValue = std::numeric_limits<float>::quiet_NaN(), const float & maximumValue = std::numeric_limits<float>::quiet_NaN());

        void pushBackFloatHdf5Array2dOfValues(float * values, const ULONG64 & valueCountInFastestDim, const ULONG64 & valueCountInSlowestDim, COMMON_NS::AbstractHdfProxy* proxy,
            const float & minimumValue = std::numeric_limits<float>::quiet_NaN(), const float & maximumValue = std::numeric_limits<float>::quiet_NaN());

        void pushBackFloatHdf5Array3dOfValues(float * values, const ULONG64 & valueCountInFastestDim, const ULONG64 & valueCountInMiddleDim, const ULONG64 & valueCountInSlowestDim, COMMON_NS::AbstractHdfProxy* proxy,
            const float & minimumValue = std::numeric_limits<float>::quiet_NaN(), const float & maximumValue = std::numeric_limits<float>::quiet_NaN());

        void pushBackFloatHdf5ArrayOfValues(float * values, unsigned long long * numValues, const unsigned int & numArrayDimensions, COMMON_NS::AbstractHdfProxy* proxy,
            float * minimumValue = nullptr, float * maximumValue = nullptr);

        void pushBackFloatHdf5ArrayOfValues(
            unsigned long long* numValues,
            const unsigned int& numArrayDimensions, 
            COMMON_NS::AbstractHdfProxy* proxy
        );

        void pushBackFloatHdf5ArrayOfValues(
            const ULONG64& valueCountInFastestDim,
            const ULONG64& valueCountInMiddleDim,
            const ULONG64& valueCountInSlowestDim,
            COMMON_NS::AbstractHdfProxy* proxy
        );

        void setValuesOfFloatHdf5ArrayOfValues(
            float* values, 
            const ULONG64& valueCountInFastestDim,
            const ULONG64& valueCountInMiddleDim,
            const ULONG64& valueCountInSlowestDim,
            const ULONG64& offsetInFastestDim,
            const ULONG64& offsetInMiddleDim,
            const ULONG64& offsetInSlowestDim,
            COMMON_NS::AbstractHdfProxy* proxy,
            unsigned int patchIndex = (std::numeric_limits<unsigned int>::max)()
        );

        void setValuesOfFloatHdf5ArrayOfValues(
            float * values, 
            unsigned long long * numValues,
            unsigned long long * offsetValues,
            const unsigned int & numArrayDimensions, 
            COMMON_NS::AbstractHdfProxy* proxy,
            unsigned int patchIndex = (std::numeric_limits<unsigned int>::max)()
        );

        std::string pushBackRefToExistingDataset(COMMON_NS::AbstractHdfProxy* hdfProxy, const std::string & datasetName = "", const long & nullValue = (std::numeric_limits<long>::max)());

        void getDoubleValuesOfPatch(const unsigned int & patchIndex, double * values);

        void getFloatValuesOfPatch(const unsigned int & patchIndex, float * values);

        void getFloatValuesOfPatch(
            const unsigned int& patchIndex, 
            float* values, 
            unsigned long long* numValuesInEachDimension,
            unsigned long long* offsetInEachDimension,
            const unsigned int& numArrayDimensions
        );

        void getFloatValuesOf3dPatch(
            const unsigned int& patchIndex, 
            float* values, 
            const ULONG64& valueCountInFastestDim,
            const ULONG64& valueCountInMiddleDim,
            const ULONG64& valueCountInSlowestDim,
            const ULONG64& offsetInFastestDim,
            const ULONG64& offsetInMiddleDim,
            const ULONG64& offsetInSlowestDim
        );

        /*
        * Get the minimum value in this continuous properties. It reads it from file.
        * @return the minimum value if present in the file otherwise NaN.
        */
        double getMinimumValue();

        /*
        * Get the maximum value in this discrete properties. It reads it from file.
        * @return the maximum value if present in the file otherwise NaN.
        */
        double getMaximumValue();

        bool validatePropertyKindAssociation(RESQML2_NS::PropertyKind* pk);

        bool validatePropertyKindAssociation(const gsoap_resqml2_0_1::resqml2__ResqmlPropertyKind & pk);

    private:

        template <class T>
        void setPropertyMinMax(
            T* values, 
            unsigned long long* numValuesInEachDimension,
            const unsigned int& numArrayDimensions,
            T * minimumValue = nullptr, T * maximumValue = nullptr)
        {
            gsoap_resqml2_0_1::_resqml2__ContinuousProperty* prop = static_cast<gsoap_resqml2_0_1::_resqml2__ContinuousProperty*>(gsoapProxy2_0_1);
            prop->MinimumValue.clear();
            prop->MaximumValue.clear();

            if (minimumValue != nullptr && maximumValue != nullptr) {
                for (unsigned int i = 0; i < prop->Count; ++i)
                {
                    prop->MinimumValue.push_back(minimumValue[i]);
                    prop->MaximumValue.push_back(maximumValue[i]);
                }
            }
            else {

                ULONG64 nValues = numValuesInEachDimension[0];
                if (prop->Count == 1) {
                    for (unsigned int dim = 1; dim < numArrayDimensions; dim++) {
                        nValues *= numValuesInEachDimension[dim];
                    }
                }
                else if (prop->Count > 1) {
                    //In this case, the last (fastest) dimension has the number of properties per indexable element of the representation.
                    for (unsigned int dim = 1; dim < numArrayDimensions - 1; dim++) {
                        nValues *= numValuesInEachDimension[dim];
                    }
                }
                else {
                    throw std::invalid_argument("Cannot compute and set min and max value on a property which has a Count set to zero or negative.");
                }

                for (ULONG64 propIndex = 0; propIndex < prop->Count; ++propIndex) {
                    size_t i = propIndex;
                    T computedMin = std::numeric_limits<T>::quiet_NaN();
                    T computedMax = std::numeric_limits<T>::quiet_NaN();
                    while (i < nValues && values[i] != values[i]) i += prop->Count;
                    if (i >= nValues) {
                        // All values of a dimension of the vectorial property look to be only NaN values.
                        if (prop->Count == 1) {
                            return; // Does not set min and max value
                        }
                        else { // Set min and max as NaN values
                            prop->MinimumValue.push_back(std::numeric_limits<T>::quiet_NaN());
                            prop->MaximumValue.push_back(std::numeric_limits<T>::quiet_NaN());
                        }
                    }
                    computedMin = values[i];
                    computedMax = values[i];

                    for (; i < nValues; i += prop->Count) {
                        T propVal = values[i];
                        if (propVal < computedMin) {
                            computedMin = propVal;
                        }
                        else if (propVal > computedMax) {
                            computedMax = propVal;
                        }
                    }
                    prop->MinimumValue.push_back(computedMin);
                    prop->MaximumValue.push_back(computedMax);
                }
            }
        }
    };
}