X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling%2FMEDCouplingSkyLineArray.hxx;h=e2dca0b59fa93520b08d6c345e98642571c59110;hb=04f1c450d57b28c7c473bdc59dc87eeef7393ca5;hp=c12dc6b681a05363f94cb6c7331878b0db6118c2;hpb=1ca2b215a1ae474745fabc87dd9c5c98e9af6354;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling/MEDCouplingSkyLineArray.hxx b/src/MEDCoupling/MEDCouplingSkyLineArray.hxx index c12dc6b68..e2dca0b59 100644 --- a/src/MEDCoupling/MEDCouplingSkyLineArray.hxx +++ b/src/MEDCoupling/MEDCouplingSkyLineArray.hxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D +// Copyright (C) 2007-2020 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -17,40 +17,152 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -#ifndef __PARAMEDMEM_MEDCOUPLINGSKYLINEARRAY_HXX__ -#define __PARAMEDMEM_MEDCOUPLINGSKYLINEARRAY_HXX__ +#pragma once #include "MEDCoupling.hxx" #include "MEDCouplingMemArray.hxx" -#include "MEDCouplingAutoRefCountObjectPtr.hxx" +#include "MCAuto.hxx" +#include "NormalizedGeometricTypes" #include +#include -namespace ParaMEDMEM +namespace MEDCoupling { - class MEDCOUPLING_EXPORT MEDCouplingSkyLineArray + /**! + * Class allowing the easy manipulation of the indexed array format, where the first array (the "indices") is a set of offsets to + * be used in the second array (the "values"), to extract packs of values. + * + * Example: + * index = [0,2,7,10] + * values = [1,24,2,33,6,7,10,11,9,28] + * which describes 3 packs of (integer) values : [1,24] and [2,33,6,7,10] and [11,9,28] + * + * Thus the index array is always monotic ascendant. + * + * This class allows to pursue this logic up to 3 levels, i.e. the first array (the "indices") points to packs in the + * second (the "values"), which itself points to identifiers in a third array (the "sub-values"). + * + * This particularly useful for connectivity of pure polygonal/polyhedral meshes. + * + * Example: + * super-index = [0,1,3] + * index = [0,3,6,10] + * values = [28,1,4,2,35,8,9,10,1,12] + * which represent two 3 packs and two super-packs. The first super-pack is [[28,1,4]] and has only one pack [28,1,4]. + * The second super-pack is [[2,35,8], [9,10,1,12]] and has two packs [2,35,8] and [9,10,1,12]. + * Note that contrary to index, the integers in super-index are interpreted as being inclusive: the first super-pack + * goes from offset 0 to offset 1, inclusive. This is not the same for index, where the upper bound is exclusive. + */ + class MEDCOUPLING_EXPORT MEDCouplingSkyLineArray : public RefCountObject { - private: - MEDCouplingAutoRefCountObjectPtr _index; - MEDCouplingAutoRefCountObjectPtr _value; public: - MEDCouplingSkyLineArray(); - MEDCouplingSkyLineArray( const MEDCouplingSkyLineArray &myArray ); - MEDCouplingSkyLineArray( const std::vector& index, const std::vector& value ); - MEDCouplingSkyLineArray( DataArrayInt* index, DataArrayInt* value ); - ~MEDCouplingSkyLineArray(); + static MEDCouplingSkyLineArray * New(); + static MEDCouplingSkyLineArray * New( const std::vector& index, const std::vector& value); + static MEDCouplingSkyLineArray * New( DataArrayIdType* index, DataArrayIdType* value ); + static MEDCouplingSkyLineArray * New( const MEDCouplingSkyLineArray & other ); + + static MEDCouplingSkyLineArray * BuildFromPolyhedronConn( const DataArrayIdType* c, const DataArrayIdType* cI ); + + static std::vector< MCAuto > RetrieveVecIndex(const std::vector< MCAuto >& vecSka) + { + auto fct = [](MEDCouplingSkyLineArray *ska) { return ska->getIndexArray(); }; + return RetrieveVecOfSkyLineArrayGen(vecSka,fct); + } + + static std::vector< MCAuto > RetrieveVecValues(const std::vector< MCAuto >& vecSka) + { + auto fct = [](MEDCouplingSkyLineArray *ska) { return ska->getValuesArray(); }; + return RetrieveVecOfSkyLineArrayGen(vecSka,fct); + } + + static std::vector< MCAuto > RetrieveVecOfSkyLineArrayGen(const std::vector< MCAuto >& vecSka, std::function fct) + { + std::size_t sz(vecSka.size()); + std::vector< MCAuto > ret(sz); + std::vector< MCAuto >::iterator it(ret.begin()); + std::for_each(vecSka.begin(),vecSka.end(),[&it,fct](MCAuto elt) { *it++ = MCAuto::TakeRef(fct(elt)); } ); + return ret; + } + + std::string getClassName() const override { return std::string("MEDCouplingSkyLineArray"); } + std::size_t getHeapMemorySizeWithoutChildren() const; + std::vector getDirectChildrenWithNull() const; + + void set( DataArrayIdType* index, DataArrayIdType* value ); + void set3( DataArrayIdType* superIndex, DataArrayIdType* index, DataArrayIdType* value ); - void set( DataArrayInt* index, DataArrayInt* value ); + mcIdType getSuperNumberOf() const { return ToIdType(_super_index->getNbOfElems())-1; } + mcIdType getNumberOf() const { return ToIdType(_index->getNbOfElems())-1; } + mcIdType getLength() const { return ToIdType(_values->getNbOfElems()); } - int getNumberOf() const { return _index->getNbOfElems()-1; } - int getLength() const { return _value->getNbOfElems(); } - const int* getIndex() const { return _index->begin(); } - const int* getValue() const { return _value->begin(); } + const mcIdType* getSuperIndex() const { return _super_index->begin(); } + const mcIdType* getIndex() const { return _index->begin(); } + const mcIdType* getValues() const { return _values->begin(); } - DataArrayInt* getIndexArray() const; - DataArrayInt* getValueArray() const; + DataArrayIdType* getSuperIndexArray() const; + DataArrayIdType* getIndexArray() const; + DataArrayIdType* getValuesArray() const; + + MEDCouplingSkyLineArray *deepCopy() const; std::string simpleRepr() const; + + void thresholdPerPack(mcIdType threshold, MCAuto& left, MCAuto& right) const; + + MEDCouplingSkyLineArray *groupPacks(const DataArrayIdType *indexedPacks) const; + MEDCouplingSkyLineArray *uniqueNotSortedByPack() const; + static MEDCouplingSkyLineArray *AggregatePacks(const std::vector& sks); + + void getSimplePackSafe(const mcIdType absolutePackId, std::vector & pack) const; + const mcIdType * getSimplePackSafePtr(const mcIdType absolutePackId, mcIdType & packSize) const; + void findPackIds(const std::vector & superPackIndices, const mcIdType *packBg, const mcIdType *packEnd, + std::vector& out) const; + + void deletePack(const mcIdType superIdx, const mcIdType idx); + void deleteSimplePack(const mcIdType idx); + void pushBackPack(const mcIdType superIdx, const mcIdType * packBg, const mcIdType * packEnd); + + void replaceSimplePack(const mcIdType idx, const mcIdType * packBg, const mcIdType * packEnd); + void replacePack(const mcIdType superIdx, const mcIdType idx, const mcIdType * packBg, const mcIdType * packEnd); + + void deleteSimplePacks(const DataArrayIdType* idx); + void replaceSimplePacks(const DataArrayIdType* idx, const std::vector& packs); + + void convertToPolyhedronConn( MCAuto& c, MCAuto& cI) const; + + private: + MEDCouplingSkyLineArray(); + ~MEDCouplingSkyLineArray(); + + void checkSuperIndex(const std::string& func) const; + void validSuperIndex(const std::string& func, mcIdType superIndex) const; + void validIndex(const std::string& func, mcIdType index) const; + void validSuperIndexAndIndex(const std::string& func, mcIdType superIndex, mcIdType index) const; + + MCAuto _super_index; + MCAuto _index; + MCAuto _values; }; + + template + class SkyLineArrayGenIterator : public std::iterator< std::input_iterator_tag, const mcIdType *, mcIdType, const mcIdType **, const mcIdType *> + { + std::size_t _num = 0; + std::vector *_data = nullptr; + public: + explicit SkyLineArrayGenIterator(std::size_t num , std::vector *data) : _num(num),_data(data) {} + SkyLineArrayGenIterator& operator++() { ++_num; return *this; } + bool operator==(const SkyLineArrayGenIterator& other) const { return _num == other._num; } + bool operator!=(const SkyLineArrayGenIterator& other) const { return !(*this == other); } + reference operator*() const { T tt; return tt((*_data)[_num]); } + }; + + struct SkyLineArrayIndexPtrFunctor { const mcIdType *operator()(const MEDCouplingSkyLineArray *ska) { return ska->getIndex(); } }; + + using SkyLineArrayIndexIterator = SkyLineArrayGenIterator; + + struct SkyLineArrayValuesPtrFunctor { const mcIdType *operator()(const MEDCouplingSkyLineArray *ska) { return ska->getValues(); } }; + + using SkyLineArrayValuesIterator = SkyLineArrayGenIterator; } -# endif