AbstractRepresentation.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 <set>

#include "resqml2/AbstractProperty.h"

namespace COMMON_NS {
    class AbstractHdfProxy;
}

namespace RESQML2_NS
{
    class DLL_IMPORT_OR_EXPORT AbstractRepresentation : public COMMON_NS::AbstractObject
    {
    protected:

        AbstractRepresentation(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject) : COMMON_NS::AbstractObject(partialObject), interpretation(nullptr), hdfProxy(nullptr), localCrs(nullptr) {}

        AbstractRepresentation(class AbstractFeatureInterpretation* interp, class AbstractLocal3dCrs * crs);

        AbstractRepresentation(gsoap_resqml2_0_1::resqml2__AbstractRepresentation* fromGsoap) : COMMON_NS::AbstractObject(fromGsoap), interpretation(nullptr), hdfProxy(nullptr), localCrs(nullptr) {}

        void pushBackSeismicSupport(AbstractRepresentation * seismicSupport);

        void setXmlInterpretation(class AbstractFeatureInterpretation * interp);

        virtual gsoap_resqml2_0_1::resqml2__PointGeometry* getPointGeometry2_0_1(const unsigned int & patchIndex) const { return nullptr; }

        gsoap_resqml2_0_1::resqml2__PointGeometry* createPointGeometryPatch2_0_1(const unsigned int & patchIndex, double * points, unsigned long long * numPoints, const unsigned int & numDimensionsInArray, COMMON_NS::AbstractHdfProxy * proxy);

        std::string getHdfProxyUuidFromPointGeometryPatch(gsoap_resqml2_0_1::resqml2__PointGeometry* patch) const;

        gsoap_resqml2_0_1::resqml2__Seismic2dCoordinates* getSeismic2dCoordinates(const unsigned int & patchIndex) const;

        gsoap_resqml2_0_1::resqml2__Seismic3dCoordinates* getSeismic3dCoordinates(const unsigned int & patchIndex) const;

    public:

        enum indexableElement { NODE = 0, EDGE = 1, FACE = 2, VOLUME = 3, PILLAR = 4 };

        virtual ~AbstractRepresentation() {}

        class AbstractLocal3dCrs* getLocalCrs() const;

        virtual gsoap_resqml2_0_1::eml20__DataObjectReference* getLocalCrsDor() const;
        
        std::string getLocalCrsUuid() const;

        COMMON_NS::AbstractHdfProxy* getHdfProxy() const;

        /*
         * Getter for the uuid of the hdf proxy which is used for storing the numerical values of this representation i.e. geometry.
         * An empty string is returned if no hdf proxy is used for storing the representation/geometry.
         */
        virtual std::string getHdfProxyUuid() const = 0;

        const std::vector<class AbstractProperty*> & getPropertySet() const;

        std::vector<class AbstractValuesProperty*> getValuesPropertySet() const;

        unsigned int getValuesPropertyCount() const;

        class AbstractValuesProperty* getValuesProperty(const unsigned int & index) const;

        void setInterpretation(class AbstractFeatureInterpretation * interp);

        class AbstractFeatureInterpretation* getInterpretation() const;

        gsoap_resqml2_0_1::eml20__DataObjectReference* getInterpretationDor() const;

        std::string getInterpretationUuid() const;

        std::string getInterpretationContentType() const;

        void pushBackSubRepresentation(class SubRepresentation* subRep);

        std::vector<SubRepresentation*> getSubRepresentationSet() const;

        unsigned int getSubRepresentationCount() const;

        SubRepresentation* getSubRepresentation(const unsigned int & index) const;

        std::vector<SubRepresentation*> getFaultSubRepresentationSet() const;

        unsigned int getFaultSubRepresentationCount() const;

        SubRepresentation* getFaultSubRepresentation(const unsigned int & index) const;
        
        virtual ULONG64 getXyzPointCountOfPatch(const unsigned int & patchIndex) const = 0;

        ULONG64 getXyzPointCountOfAllPatches() const;

         virtual void getXyzPointsOfPatch(const unsigned int & patchIndex, double * xyzPoints) const = 0;

        void getXyzPointsOfPatchInGlobalCrs(const unsigned int & patchIndex, double * xyzPoints) const;

        void getXyzPointsOfAllPatches(double * xyzPoints) const;

        void getXyzPointsOfAllPatchesInGlobalCrs(double * xyzPoints) const;

        AbstractRepresentation* getSeismicSupportOfPatch(const unsigned int & patchIndex) const;

        std::set<AbstractRepresentation*> getAllSeismicSupport() const;

        virtual unsigned int getPatchCount() const = 0;

        void pushBackIntoRepresentationSet(class RepresentationSetRepresentation * repSet, bool xml = true);

        ULONG64 getRepresentationSetRepresentationCount() const;

        RepresentationSetRepresentation* getRepresentationSetRepresentation(const ULONG64  & index) const;

        void setHdfProxy(COMMON_NS::AbstractHdfProxy * proxy);

        void addSeismic3dCoordinatesToPatch(const unsigned int patchIndex, double * inlines, double * crosslines, const unsigned int & pointCount,
            RESQML2_NS::AbstractRepresentation * seismicSupport, COMMON_NS::AbstractHdfProxy * proxy);

        void addSeismic3dCoordinatesToPatch(const unsigned int patchIndex, const double & startInline, const double & incrInline, const unsigned int & countInline,
            const double & startCrossline, const double & incrCrossline, const unsigned int & countCrossline,
            RESQML2_NS::AbstractRepresentation * seismicSupport);

        void addSeismic2dCoordinatesToPatch(const unsigned int patchIndex, double * lineAbscissa,
            RESQML2_NS::AbstractRepresentation * seismicSupport, COMMON_NS::AbstractHdfProxy * proxy);

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

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

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

        static const char* XML_TAG;

    protected:

        virtual std::vector<epc::Relationship> getAllEpcRelationships() const;
        virtual void importRelationshipSetFromEpc(COMMON_NS::EpcDocument* epcDoc);

        // XML forward relationships
        class AbstractFeatureInterpretation*                interpretation;
        COMMON_NS::AbstractHdfProxy *                           hdfProxy;
        class AbstractLocal3dCrs *                          localCrs;

        // XML backward relationships
        std::vector<SubRepresentation*>                     subRepresentationSet;
        std::vector<AbstractProperty*>                      propertySet;
        std::vector<AbstractRepresentation*>                seismicSupportedRepSet;
        std::vector<class RepresentationSetRepresentation*> representationSetRepresentationSet;

        friend void AbstractProperty::setRepresentation(AbstractRepresentation * rep);
    };
}