UnstructuredGridRepresentation.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/AbstractGridRepresentation.h"

namespace RESQML2_0_1_NS
{
    class DLL_IMPORT_OR_EXPORT UnstructuredGridRepresentation : public RESQML2_NS::AbstractGridRepresentation
    {
    private :

        void init(soap* soapContext, RESQML2_NS::AbstractLocal3dCrs * crs,
                const std::string & guid, const std::string & title,
                const ULONG64 & cellCount);
        
        gsoap_resqml2_0_1::_resqml2__UnstructuredGridRepresentation* getSpecializedGsoapProxy() const;

        gsoap_resqml2_0_1::resqml2__PointGeometry* getPointGeometry2_0_1(const unsigned int & patchIndex) const;

        void setConstantCellShapeGeometryUsingExistingDatasets(const std::string& cellFaceIsRightHanded, const std::string& points,
            ULONG64 pointCount, ULONG64 faceCount, COMMON_NS::AbstractHdfProxy* proxy,
            const std::string& faceIndicesPerCell, ULONG64 faceCountPerCell,
            const std::string& nodeIndicesPerFace, ULONG64 nodeCountPerFace);

        void setConstantCellShapeGeometry(unsigned char * cellFaceIsRightHanded, double * points,
            ULONG64 pointCount, ULONG64 faceCount, COMMON_NS::AbstractHdfProxy* proxy,
            ULONG64 * faceIndicesPerCell, ULONG64 faceCountPerCell,
            ULONG64 * nodeIndicesPerFace, ULONG64 nodeCountPerFace);

        unsigned int constantNodeCountPerFace;
        unsigned int constantFaceCountPerCell;
        ULONG64 * cumulativeNodeCountPerFace;
        ULONG64 * cumulativeFaceCountPerCell;
        ULONG64 * nodeIndicesOfFaces;
        ULONG64 * faceIndicesOfCells;

    public:

        UnstructuredGridRepresentation(gsoap_resqml2_0_1::eml20__DataObjectReference* partialObject):
            RESQML2_NS::AbstractGridRepresentation(partialObject, false), constantNodeCountPerFace(0), constantFaceCountPerCell(0),
            cumulativeNodeCountPerFace(nullptr), cumulativeFaceCountPerCell(nullptr),
            nodeIndicesOfFaces(nullptr), faceIndicesOfCells(nullptr)
        {
        }

        UnstructuredGridRepresentation(soap* soapContext, RESQML2_NS::AbstractLocal3dCrs * crs,
            const std::string & guid, const std::string & title,
            const ULONG64 & cellCount);

        UnstructuredGridRepresentation(RESQML2_NS::AbstractFeatureInterpretation* interp, RESQML2_NS::AbstractLocal3dCrs * crs,
            const std::string & guid, const std::string & title,
            const ULONG64 & cellCount);

        UnstructuredGridRepresentation(gsoap_resqml2_0_1::_resqml2__UnstructuredGridRepresentation* fromGsoap):
            RESQML2_NS::AbstractGridRepresentation(fromGsoap, false), constantNodeCountPerFace(0), constantFaceCountPerCell(0),
            cumulativeNodeCountPerFace(nullptr), cumulativeFaceCountPerCell(nullptr),
            nodeIndicesOfFaces(nullptr), faceIndicesOfCells(nullptr) {}

        virtual ~UnstructuredGridRepresentation() {}

        bool hasGeometry() const;

        std::string getHdfProxyUuid() const;

        ULONG64 getXyzPointCountOfPatch(const unsigned int & patchIndex) const;

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

        void getFaceIndicesOfCells(ULONG64 * faceIndices) const;

        void getCumulativeFaceCountPerCell(ULONG64 * cumulativeFaceCountPerCell) const;

        void getFaceCountPerCell(ULONG64 * faceCountPerCell) const;

        bool isFaceCountOfCellsConstant() const;

        /*
        * Get the constant face count per cell in the grid.
        */
        unsigned int getConstantFaceCountOfCells() const;

        void getNodeIndicesOfFaces(ULONG64 * nodeIndices) const;

        void getCumulativeNodeCountPerFace(ULONG64 * nodeCountPerFace) const;

        void getNodeCountPerFace(ULONG64 * nodeCountPerFace) const;

        bool isNodeCountOfFacesConstant() const;

        /*
        * Get the constant node count per face in the grid.
        */
        unsigned int getConstantNodeCountOfFaces() const;

        void loadGeometry();

        void unloadGeometry();

        unsigned int getFaceCountOfCell(const ULONG64 & cellIndex) const;
    
        unsigned int getNodeCountOfFaceOfCell(const ULONG64 & cellIndex, const unsigned int & localFaceIndex) const;

        ULONG64 * getNodeIndicesOfFaceOfCell(const ULONG64 & cellIndex, const unsigned int & localFaceIndex) const;

        ULONG64 getCellCount() const;

        ULONG64 getFaceCount() const;

        ULONG64 getNodeCount() const;

        void getCellFaceIsRightHanded(unsigned char* cellFaceIsRightHanded) const;

        void setGeometryUsingExistingDatasets(const std::string& cellFaceIsRightHanded, const std::string& points, ULONG64 pointCount, COMMON_NS::AbstractHdfProxy* proxy,
            const std::string& faceIndicesPerCell, const std::string&faceIndicesCumulativeCountPerCell,
            ULONG64 faceCount, const std::string& nodeIndicesPerFace, const std::string& nodeIndicesCumulativeCountPerFace,
            const gsoap_resqml2_0_1::resqml2__CellShape & cellShape);

        void setGeometry(unsigned char * cellFaceIsRightHanded, double * points, ULONG64 pointCount, COMMON_NS::AbstractHdfProxy* proxy,
            ULONG64 * faceIndicesPerCell, ULONG64 * faceIndicesCumulativeCountPerCell,
            ULONG64 faceCount, ULONG64 * nodeIndicesPerFace, ULONG64 * nodeIndicesCumulativeCountPerFace,
            const gsoap_resqml2_0_1::resqml2__CellShape & cellShape);

        void setTetrahedraOnlyGeometryUsingExistingDatasets(const std::string& cellFaceIsRightHanded, const std::string& points,
            ULONG64 pointCount, ULONG64 faceCount, COMMON_NS::AbstractHdfProxy* proxy,
            const std::string& faceIndicesPerCell, const std::string& nodeIndicesPerFace);

        void setTetrahedraOnlyGeometry(unsigned char * cellFaceIsRightHanded, double * points,
            ULONG64 pointCount, ULONG64 faceCount, COMMON_NS::AbstractHdfProxy* proxy,
            ULONG64 * faceIndicesPerCell, ULONG64 * nodeIndicesPerFace);

        void setHexahedraOnlyGeometryUsingExistingDatasets(const std::string& cellFaceIsRightHanded, const std::string& points,
            ULONG64 pointCount, ULONG64 faceCount, COMMON_NS::AbstractHdfProxy* proxy,
            const std::string& faceIndicesPerCell, const std::string& nodeIndicesPerFace);

        void setHexahedraOnlyGeometry(unsigned char * cellFaceIsRightHanded, double * points,
            ULONG64 pointCount, ULONG64 faceCount, COMMON_NS::AbstractHdfProxy* proxy,
            ULONG64 * faceIndicesPerCell, ULONG64 * nodeIndicesPerFace);

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

        unsigned int getPatchCount() const {return 1;}
    };
}