saberbud/PoissonRecon
1
0
Fork 0
mirror of https://github.com/CloudCompare/PoissonRecon.git synced 2026-08-30 00:50:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

no message

Browse Source
This commit is contained in:
DESKTOP-P4IRLQG\mkazh
2018-04-14 23:00:29 -04:00
parent 16375a7892
commit 514b259540
190 changed files with 84512 additions and 16888 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Src/SparseMatrix.h
+58 -148
View File
@@ -25,170 +25,80 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
*/
#ifndef __SPARSEMATRIX_HPP
#define __SPARSEMATRIX_HPP
#define NEW_SPARSE_MATRIX 1
#define ZERO_TESTING_JACOBI 1
#include "SparseMatrixInterface.h"
#include "Array.h"
template <class T>
struct MatrixEntry
template< class T , class IndexType=int > class SparseMatrix : public SparseMatrixInterface< T , ConstPointer( MatrixEntry< T , IndexType > ) >
{
MatrixEntry( void ) { N =-1; Value = 0; }
MatrixEntry( int i ) { N = i; Value = 0; }
MatrixEntry( int i , T v ) { N = i; Value = v; }
int N;
T Value;
};
template<class T> class SparseMatrix
{
private:
bool _contiguous;
int _maxEntriesPerRow;
void _init( void );
template< class T2 , class IndexType2 > friend class SparseMatrix;
Pointer( Pointer( MatrixEntry< T , IndexType > ) ) _entries;
public:
int rows;
Pointer( int ) rowSizes;
Pointer( Pointer( MatrixEntry< T > ) ) m_ppElements;
Pointer( MatrixEntry< T > ) operator[] ( int idx ) { return m_ppElements[idx]; }
ConstPointer( MatrixEntry< T > ) operator[] ( int idx ) const { return m_ppElements[idx]; }
static void Swap( SparseMatrix& M1 , SparseMatrix& M2 )
{
std::swap( M1.rowNum , M2.rowNum );
std::swap( M1.rowSizes , M2.rowSizes );
std::swap( M1._entries , M2._entries );
}
typedef SparseMatrixInterface< T , ConstPointer( MatrixEntry< T , IndexType > ) > Interface;
typedef ConstPointer( MatrixEntry< T , IndexType > ) RowIterator;
size_t rowNum;
Pointer( size_t ) rowSizes;
SparseMatrix( void );
SparseMatrix( int rows );
SparseMatrix( int rows , int maxEntriesPerRow );
void Resize( int rows );
void Resize( int rows , int maxEntriesPerRow );
void SetRowSize( int row , int count );
int Entries( void ) const;
SparseMatrix( const SparseMatrix& M );
SparseMatrix( SparseMatrix&& M );
template< class T2 , class IndexType2 >
SparseMatrix( const SparseMatrix< T2 , IndexType2 >& M );
~SparseMatrix();
SparseMatrix& operator = ( SparseMatrix&& M );
SparseMatrix< T , IndexType >& operator = ( const SparseMatrix< T , IndexType >& M );
template< class T2 , class IndexType2 >
SparseMatrix< T , IndexType >& operator = ( const SparseMatrix< T2 , IndexType2 >& M );
void SetZero();
template< class T2 > void operator()( const T2* in , T2* out ) const;
SparseMatrix<T>& operator = (const SparseMatrix<T>& M);
template< class T2 , class IndexType2 >
SparseMatrix< T , IndexType >& copy( const SparseMatrix< T2 , IndexType2 >& M );
SparseMatrix<T> operator * (const T& V) const;
SparseMatrix<T>& operator *= (const T& V);
inline ConstPointer( MatrixEntry< T , IndexType > ) begin( size_t row ) const { return _entries[row]; }
inline ConstPointer( MatrixEntry< T , IndexType > ) end ( size_t row ) const { return _entries[row] + (unsigned long long)rowSizes[row]; }
inline size_t rows ( void ) const { return rowNum; }
inline size_t rowSize ( size_t idx ) const { return rowSizes[idx]; }
template< class T2 > void Multiply( ConstPointer( T2 ) in , Pointer( T2 ) out , int threads=1 ) const;
template< class T2 > void MultiplyAndAddAverage( ConstPointer( T2 ) in , Pointer( T2 ) out , int threads=1 ) const;
SparseMatrix( size_t rowNum );
void resize ( size_t rowNum );
void setRowSize( size_t row , size_t count );
void resetRowSize( size_t row , size_t count );
inline Pointer( MatrixEntry< T , IndexType > ) operator[] ( size_t idx ) { return _entries[idx]; }
inline ConstPointer( MatrixEntry< T , IndexType > ) operator[] ( size_t idx ) const { return _entries[idx]; }
// With copy move, these should be well-behaved from a memory perspective
static SparseMatrix Identity( size_t dim );
SparseMatrix transpose( T (*TransposeFunction)( const T& )=NULL ) const;
SparseMatrix transpose( size_t outRows , T (*TransposeFunction)( const T& )=NULL ) const;
SparseMatrix operator * ( T s ) const;
SparseMatrix operator / ( T s ) const;
SparseMatrix operator * ( const SparseMatrix& M ) const;
SparseMatrix operator + ( const SparseMatrix& M ) const;
SparseMatrix operator - ( const SparseMatrix& M ) const;
SparseMatrix& operator *= ( T s );
SparseMatrix& operator /= ( T s );
SparseMatrix& operator *= ( const SparseMatrix& M );
SparseMatrix& operator += ( const SparseMatrix& M );
SparseMatrix& operator -= ( const SparseMatrix& M );
bool write( FILE* fp ) const;
bool write( const char* fileName ) const;
bool read( FILE* fp );
bool read( const char* fileName );
Pointer( T ) operator * ( const Pointer( T ) in ) const;
template< class T2 > void getDiagonal( Pointer( T2 ) diagonal , int threads=1 ) const;
template< class T2 > static int SolveJacobi( const SparseMatrix<T>& M , ConstPointer( T2 ) b , Pointer( T2 ) x , Pointer( T2 ) Mx , T2 sor , int threads=1 );
template< class T2 > static int SolveJacobi( const SparseMatrix<T>& M , ConstPointer( T2 ) diagonal , ConstPointer( T2 ) b , Pointer( T2 ) x , Pointer( T2 ) Mx , T2 sor , int threads=1 );
template< class T2 > static int SolveGS( const SparseMatrix<T>& M , ConstPointer( T2 ) b , Pointer( T2 ) x , bool forward );
template< class T2 > static int SolveGS( const SparseMatrix<T>& M , ConstPointer( T2 ) diagonal , ConstPointer( T2 ) b , Pointer( T2 ) x , bool forward );
template< class T2 > static int SolveGS( const std::vector< std::vector< int > >& mcIndices , const SparseMatrix<T>& M , ConstPointer( T2 ) diagonal , ConstPointer( T2 ) b , Pointer( T2 ) x , bool forward , int threads=1 );
template< class T2 > static int SolveGS( const std::vector< std::vector< int > >& mcIndices , const SparseMatrix<T>& M , ConstPointer( T2 ) b , Pointer( T2 ) x , bool forward , int threads=1 );
template< class T2 > static int SolveCG( const SparseMatrix<T>& M , ConstPointer( T2 ) b , int iters , Pointer( T2 ) x , T2 eps=1e-8 , int reset=1 , bool addDCTerm=false , bool solveNormal=false , int threads=1 );
template< class A_const_iterator , class B_const_iterator >
static SparseMatrix Multiply( const SparseMatrixInterface< T , A_const_iterator >& A , const SparseMatrixInterface< T , B_const_iterator >& B );
template< class const_iterator >
static SparseMatrix Transpose( const SparseMatrixInterface< T , const_iterator >& At , T (*TransposeFunction)( const T& )=NULL );
template< class const_iterator >
static SparseMatrix Transpose( const SparseMatrixInterface< T , const_iterator >& At , size_t outRows , T (*TransposeFunction)( const T& )=NULL );
};
#if !NEW_SPARSE_MATRIX
template< class T2 >
struct MapReduceVector
{
private:
int _dim;
public:
std::vector< T2* > out;
MapReduceVector( void ) { _dim = 0; }
~MapReduceVector( void )
{
if( _dim ) for( int t=0 ; t<int(out.size()) ; t++ ) delete[] out[t];
out.resize( 0 );
}
T2* operator[]( int t ) { return out[t]; }
const T2* operator[]( int t ) const { return out[t]; }
int threads( void ) const { return int( out.size() ); }
void resize( int threads , int dim )
{
if( threads!=out.size() || _dim<dim )
{
for( int t=0 ; t<int(out.size()) ; t++ ) delete[] out[t];
out.resize( threads );
for( int t=0 ; t<int(out.size()) ; t++ ) out[t] = new T2[dim];
_dim = dim;
}
}
};
template< class T >
class SparseSymmetricMatrix : public SparseMatrix< T >
{
public:
template< class T2 >
Vector< T2 > operator * ( const Vector<T2>& V ) const;
template< class T2 >
Vector< T2 > Multiply( const Vector<T2>& V ) const;
template< class T2 >
void Multiply( const Vector<T2>& In, Vector<T2>& Out , bool addDCTerm=false ) const;
template< class T2 >
void Multiply( const Vector<T2>& In, Vector<T2>& Out , MapReduceVector< T2 >& OutScratch , bool addDCTerm=false ) const;
template< class T2 >
void Multiply( const Vector<T2>& In, Vector<T2>& Out , std::vector< T2* >& OutScratch , const std::vector< int >& bounds ) const;
template< class T2 >
static int SolveCG( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , T2 eps=1e-8 , int reset=1 , int threads=0 , bool addDCTerm=false , bool solveNormal=false );
template< class T2 >
static int SolveCG( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , MapReduceVector<T2>& scratch , T2 eps=1e-8 , int reset=1 , bool addDCTerm=false , bool solveNormal=false );
#ifdef WIN32
template< class T2 >
static int SolveCGAtomic( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , T2 eps=1e-8 , int reset=1 , int threads=0 , bool solveNormal=false );
#endif // WIN32
template< class T2 >
static int SolveJacobi( const SparseSymmetricMatrix<T>& M , const Vector<T2>& diagonal , const Vector<T2>& b , Vector<T2>& x , MapReduceVector<T2>& scratch , Vector<T2>& Mx , T2 sor , int reset );
template< class T2 >
static int SolveJacobi( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , MapReduceVector<T2>& scratch , T2 sor=T2(1.) , int reset=1 );
template< class T2 >
static int SolveJacobi( const SparseSymmetricMatrix<T>& M , const Vector<T2>& diagonal , const Vector<T2>& b , Vector<T2>& x , Vector<T2>& Mx , T2 sor , int reset );
template< class T2 >
static int SolveJacobi( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , T2 sor=T2(1.) , int reset=1 );
enum
{
ORDERING_UPPER_TRIANGULAR ,
ORDERING_LOWER_TRIANGULAR ,
ORDERING_NONE
};
template< class T2 >
static int SolveGS( const std::vector< std::vector< int > >& mcIndices , const SparseSymmetricMatrix<T>& M , const Vector<T2>& diagonal , const Vector<T2>& b , Vector<T2>& x , MapReduceVector<T2>& scratch , Vector<T2>& Mx , Vector<T2>& dx , bool forward , int reset );
template< class T2 >
static int SolveGS( const std::vector< std::vector< int > >& mcIndices , const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , MapReduceVector<T2>& scratch , bool forward , int reset=1 );
template< class T2 >
static int SolveGS( const SparseSymmetricMatrix<T>& M , const Vector<T2>& diagonal , const Vector<T2>& b , Vector<T2>& x , MapReduceVector<T2>& scratch , Vector<T2>& Mx , Vector<T2>& dx , bool forward , int reset , int ordering );
template< class T2 >
static int SolveGS( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , MapReduceVector<T2>& scratch , bool forward , int reset=1 , int ordering=ORDERING_NONE );
template< class T2 >
static int SolveGS( const SparseSymmetricMatrix<T>& M , const Vector<T2>& diagonal , const Vector<T2>& b , Vector<T2>& x , Vector<T2>& Mx , Vector<T2>& dx , bool forward , int reset , int ordering );
template< class T2 >
static int SolveGS( const SparseSymmetricMatrix<T>& M , const Vector<T2>& b , int iters , Vector<T2>& x , bool forward , int reset=1 , int ordering=ORDERING_NONE );
template< class T2 >
void getDiagonal( Vector< T2 >& diagonal , int threads=1 ) const;
};
#endif // !NEW_SPARSE_MATRIX
#include "SparseMatrix.inl"
#endif
#endif /* __SPARSEMATRIX_HPP */