kome::objects::DataMapInfo Class Reference

deta map information More...

#include <DataMapInfo.h>

Collaboration diagram for kome::objects::DataMapInfo:

Classes
struct	TmpData
	temporary data More...

Public Member Functions
	DataMapInfo (DataGroupNode &group, const unsigned int row, const unsigned int col)
	constructor More...
virtual	~DataMapInfo ()
	destructor
unsigned int	getRowSize ()
	gets row size More...
unsigned int	getColSize ()
	gets column size More...
DataGroupNode &	getGroup ()
	gets raw data More...
Sample *	getSample ()
	gets sample More...
double	getMinMz ()
	gets min m/z More...
double	getMaxMz ()
	gets max m/z More...
double	getMinRt ()
	gets min RT More...
double	getMaxRt ()
	gets max RT More...
double	getMinIntensity ()
	gets min intensity More...
double	getMaxIntensity ()
	gets max intensity More...
double	getIntensity (const unsigned int row, const unsigned int col)
	gets the intensity of the image map More...
void	setCompleted (const bool completed)
	sets completed flag More...
bool	isCompleted ()
	gets completed flag More...
void	setIntensityRange (const double minInt, const double maxInt)
	sets intensity range More...
bool	setRange (double minMz, double maxMz, double minRt, double maxRt, const char *filterName, kome::core::Progress &progress)
	sets data map range More...
void	setAutoCommit (const bool autoCommit)
	sets auto commit flag More...
bool	isAutoCommit ()
	gets auto commit flag More...
void	commit ()
	commit data
void	rollback ()
	rollback data
bool	saveDataMap (const char *path)
	saves data map More...
bool	loadDataMap (const char *path)
	loads data map More...

Protected Member Functions
void	createImageMap (std::vector< kome::objects::Spectrum * > &spectra, kome::core::Progress &progress)
	creates image map More...
void	getSpecIntensities (Spectrum *spec, double *intensities, int size)
	gets intensities of spectrum More...
void	getSpecArray (const char *filterName, std::vector< kome::objects::Spectrum * > &tmpSpecArray)
	get spectrum array More...
void	createTmpData ()
	creates temporary data
void	deleteTmpData ()
	deletes temporary data

Static Protected Member Functions
static bool	lessSpec (Spectrum *spec0, Spectrum *spec1)
	compare RT of spectrum to sort More...

Protected Attributes
unsigned int	m_row
unsigned int	m_col
DataGroupNode *	m_group
double *	m_map
double	m_minMz
double	m_maxMz
double	m_minRt
double	m_maxRt
double	m_minIntensity
double	m_maxIntensity
bool	m_completed
TmpData *	m_tmp
bool	m_autoCommit

Detailed Description

deta map information

Definition at line 31 of file DataMapInfo.h.

Constructor & Destructor Documentation

kome::objects::DataMapInfo::DataMapInfo	(	DataGroupNode &	group,
		const unsigned int	row,
		const unsigned int	col
	)

constructor

Parameters

[in]	group	spectrum group
[in]	row	row size
[in]	col	column size

Definition at line 39 of file DataMapInfo.cpp.

                                                                                               {
    // initialize
    m_row = row;
    m_group = &group;
    m_col = col;

    // create map
    unsigned int size = row * col;
    if( size == 0 ) {
        m_map = NULL;
    }
    else {
        m_map = new double[ size ];
    }

    // initialize
    m_minMz = double();
    m_maxMz = double();
    m_minRt = double();
    m_maxRt = double();
    m_maxIntensity = double();
    m_minIntensity = double();
    m_autoCommit = true;
    m_tmp = NULL;
    m_completed = false;
}

Member Function Documentation

void kome::objects::DataMapInfo::createImageMap ( std::vector< kome::objects::Spectrum * > &  spectra, kome::core::Progress &  progress  )

protected

creates image map

Parameters

[in]	spectra	spectrum array
[out]	progress	the object to show progress

Definition at line 434 of file DataMapInfo.cpp.

  {
    // intensities array
    double* prevInts = new double[ m_col ];
    double* nowInts = new double[ m_col ];

    // initialize
    m_tmp->minIntensity = 0.0;
    m_tmp->maxIntensity = 0.1;

    // unit range (RT)
    double unitRange = ( m_tmp->maxRt - m_tmp->minRt ) / (double)( m_row - 1 );
    double rtZeroRange = DEFAULT_RT_ZERO_RANGE;
    double prevRt = 0.0;
    if( m_group->getNumberOfSpectra() > 0 ) {
        prevRt = m_group->getSpectrum( 0 )->getRt() - rtZeroRange;
    }
    double prevScan = 0;
    for( unsigned int i = 0; i < m_group->getNumberOfSpectra(); i++ ) {
        kome::objects::Spectrum* spec = m_group->getSpectrum( i );
        rtZeroRange = std::max( rtZeroRange, fabs( spec->getRt() - prevRt ) );
        prevRt = spec->getRt();
        prevScan = spec->getScanNumber();
    }

    // length
    int length = (int)spectra.size();

    // create image map
    int prevIdx = -1;
    prevRt = -9999999.9;
    for( unsigned int i = 0; i < spectra.size() && !progress.isStopped() ; i++ ) {
        // spectrum 
        Spectrum* spec = spectra[ i ];

        progress.setStatus( FMT( "Getting spectrum data... [%s]", spec->getName() ).c_str() );
        progress.setPosition( 2 * length + 4 * i );

        // intensities
        getSpecIntensities( spec, nowInts, m_row );
        if( spectra.size() == 1 ) {
            prevRt = spec->getRt();
            memcpy( prevInts, nowInts, sizeof( double ) * m_col );
        }

        // intensity range
        for( unsigned int j = 0; j < m_col; j++ ) {
            if( nowInts[ j ] < m_tmp->minIntensity ) {
                m_tmp->minIntensity = nowInts[ j ];
            }
            if( nowInts[ j ] > m_tmp->maxIntensity ) {
                m_tmp->maxIntensity = nowInts[ j ];
            }
        }

        // get index
        int idx = (int)m_row - 1;
        if( spectra.size() > 1 ) {
            idx = roundnum( ( spec->getRt() - m_tmp->minRt ) / unitRange );
        }

        // set intensities
        if( idx >= 0 && idx < (int)m_row ) {
            if( idx == prevIdx ) {
                for( unsigned int j = 0; j < m_col; j++ ) {
                    int ptIdx = idx * m_col + j;
                    double prevInt = m_tmp->intensities[ ptIdx ];
                    double nowInt = nowInts[ j ];

                    if( fabs( nowInt ) > fabs( prevInt ) ) {
                        m_tmp->intensities[ ptIdx ] = nowInt;
                    }
                }
            }
            else {
                for( unsigned int j = 0; j < m_col; j++ ) {
                    int ptIdx = idx * m_col + j;
                    m_tmp->intensities[ ptIdx ] = nowInts[ j ];
                }
            }
        }

        // interpolation
        int sIdx = prevIdx + 1;
        sIdx = MAX( 0, sIdx );
        if( spec->getRt() <= prevRt + rtZeroRange ) { // linear interpolation
            for( int j = sIdx; j < idx && j < (int)m_row; j++ ) {
                double rt = m_tmp->minRt + (double)j * unitRange;

                double d1 = fabs( rt - prevRt );
                double d2 = fabs( spec->getRt() - rt );
                if( prevRt == spec->getRt() ) {
                    d1 = 1.0;
                    d2 = 0.0;
                }
                for( int k = 0; k < (int)m_col; k++ ) {
                    int ptIdx = j * m_row + k;
                    m_tmp->intensities[ ptIdx ] = ( d2 * prevInts[ k ] + d1 * nowInts[ k ] ) / ( d1 + d2 );
                }
            }
        }
        else {       // insert zero
            double zeroRange = std::min( ( spec->getRt() - prevRt ) / 2.5, rtZeroRange );

            for( int j = sIdx; j < idx && j < (int)m_row; j++ ) {
                double rt = m_tmp->minRt + (double)j * unitRange;

                if( rt > spec->getRt() - zeroRange ) {
                    double d = rt - ( spec->getRt() - zeroRange );

                    for( int k = 0; k < (int)m_col; k++ ) {
                        int ptIdx = j * m_col + k;
                        m_tmp->intensities[ ptIdx ] = ( d * nowInts[ k ] ) / zeroRange;
                    }
                }
                else if( rt < prevRt + zeroRange ) {
                    double d = zeroRange - fabs( rt - prevRt );

                    for( int k = 0; k < (int)m_col; k++ ) {
                        int ptIdx = j * m_col + k;
                        m_tmp->intensities[ ptIdx ] = ( d * prevInts[ k ] ) / zeroRange;
                    }
                }
                else {
                    for( int k = 0; k < (int)m_col; k++ ) {
                        int ptIdx = j * m_col + k;
                        m_tmp->intensities[ ptIdx ] = 0.0;
                    }
                }
            }
        }

        // set previous
        prevIdx = idx;
        prevRt = spec->getRt();
        memcpy( prevInts, nowInts, sizeof( double ) * m_row );
    }

    // delete array
    delete[] prevInts;
    delete[] nowInts;

    // check progress
    if( progress.isStopped() ) {
        return;
    }

    // log
    LOG_DEBUG(
        FMT(
            "Data Map : mz=[%.2f, %.2f] RT=[%.2f, %.2f] Int=[%.2f, %.2f]",
            m_tmp->minMz,
            m_tmp->maxMz,
            m_tmp->minRt,
            m_tmp->maxRt,
            m_tmp->minIntensity,
            m_tmp->maxIntensity
        )
    );

    // progress
    progress.fill();
}

Here is the call graph for this function:

unsigned int kome::objects::DataMapInfo::getColSize

(

)

gets column size

Returns

column size

Definition at line 86 of file DataMapInfo.cpp.

                                     {
    return m_col;
}

DataGroupNode & kome::objects::DataMapInfo::getGroup

(

)

gets raw data

Returns

raw data

Definition at line 91 of file DataMapInfo.cpp.

                                     {
    return *m_group;
}

double kome::objects::DataMapInfo::getIntensity	(	const unsigned int	row,
		const unsigned int	col
	)

gets the intensity of the image map

Parameters

[in]	row	row (RT) index
[in]	col	column (m/z) index

Returns

the intensity of the image map

Definition at line 131 of file DataMapInfo.cpp.

                                                                                 {
    int idx = row * m_col + col;

    return m_map[ idx ];
}

double kome::objects::DataMapInfo::getMaxIntensity

(

)

gets max intensity

Returns

max intensity

Definition at line 126 of file DataMapInfo.cpp.

                                    {
    return m_maxIntensity;
}

double kome::objects::DataMapInfo::getMaxMz

(

)

gets max m/z

Returns

max m/z

Definition at line 106 of file DataMapInfo.cpp.

                             {
    return m_maxMz;
}

double kome::objects::DataMapInfo::getMaxRt

(

)

gets max RT

Returns

max RT

Definition at line 116 of file DataMapInfo.cpp.

                             {
    return m_maxRt;
}

double kome::objects::DataMapInfo::getMinIntensity

(

)

gets min intensity

Returns

min intensity

Definition at line 121 of file DataMapInfo.cpp.

                                    {
    return m_minIntensity;
}

double kome::objects::DataMapInfo::getMinMz

(

)

gets min m/z

Returns

min m/z

Definition at line 101 of file DataMapInfo.cpp.

                             {
    return m_minMz;
}

double kome::objects::DataMapInfo::getMinRt

(

)

gets min RT

Returns

min RT

Definition at line 111 of file DataMapInfo.cpp.

                             {
    return m_minRt;
}

unsigned int kome::objects::DataMapInfo::getRowSize

(

)

gets row size

Returns

row size

Definition at line 81 of file DataMapInfo.cpp.

                                     {
    return m_row;
}

Sample * kome::objects::DataMapInfo::getSample

(

)

gets sample

Returns

sample

Definition at line 96 of file DataMapInfo.cpp.

                               {
    return m_group->getSample();
}

Here is the call graph for this function:

void kome::objects::DataMapInfo::getSpecArray ( const char *  filterName, std::vector< kome::objects::Spectrum * > &  tmpSpecArray  )

protected

get spectrum array

Parameters

[in]	filterName	filter name
[in]	tmpSpecArray	spectrum array

Definition at line 154 of file DataMapInfo.cpp.

                                                                                                       {
    // create temporary data
    createTmpData();

    // data set
    kome::objects::DataSet spectra;
    m_group->getDataSet( &spectra );
    spectra.sortSpectra();

    // create array
    int specNum = (int)spectra.getNumberOfSpectra();
    
    // MS
    if( strcmp( filterName, "ms" ) == 0 ){
        for( int i = 0; i < specNum; i++ ) {
            kome::objects::Spectrum* spec = spectra.getSpectrum( i );
            if( spec->getMsStage() == 1 && spec->hasChromatogram() ) {
                tmpSpecArray.push_back( spec );
            }
        }
    // MS/MS
    }else if( strcmp( filterName, "ms2" ) == 0 ){
        for( int i = 0; i < specNum; i++ ) {
            kome::objects::Spectrum* spec = spectra.getSpectrum( i );
            if( spec->getMsStage() >= 2 && spec->hasChromatogram() ) {
                tmpSpecArray.push_back( spec );
            }
        }
    // All
    }else if( strcmp( filterName, "all" ) == 0 ){
        for( int i=0; i< specNum; i++ ){
            kome::objects::Spectrum* spec = spectra.getSpectrum( i );
            if( spec->hasChromatogram() ){
                tmpSpecArray.push_back( spec );
            }
        }
    }
}

Here is the call graph for this function:

void kome::objects::DataMapInfo::getSpecIntensities ( Spectrum *  spec, double *  intensities, int  size  )

protected

gets intensities of spectrum

Parameters

[in]	spec	spectrum
[out]	intensities	the array to store intensities
[in]	size	array size

Definition at line 601 of file DataMapInfo.cpp.

  {
    // variables
    kome::core::DataPoints pt;

    // initialize
    for( int i = 0; i < size; i++ ) {
        intensities[ i ] = 0.0;
    }

    // unit range (m/z)
    double unitRange = ( m_tmp->maxMz - m_tmp->minMz ) / (double)( size - 1 );
    double mzZeroRange = std::max( DEFAULT_MZ_ZERO_RANGE, spec->getResolution() );

    // get point index
    int mzStartIdx = 0;
    int mzEndIdx = 0;
    int length = 0;

    // get points
    pt.clearPoints();
    spec->getXYData( &pt, m_tmp->minMz - mzZeroRange, m_tmp->maxMz + mzZeroRange, false );

    length = (int)pt.getLength();
    mzStartIdx = pt.searchIndex( m_tmp->minMz );
    mzEndIdx = pt.searchIndex( m_tmp->maxMz );

    if( mzStartIdx < 0 ) {
        mzStartIdx = - mzStartIdx - 2;
        mzStartIdx = MAX( 0, mzStartIdx );
    }
    if( mzEndIdx < 0 ) {
        mzEndIdx = - mzEndIdx - 1;
        mzEndIdx = MIN( length - 1, mzEndIdx );
    }

    // get data points
    int prevIdx = -1;
    double prevMz = -9999999.9;
    double prevInt = 0.0;
    for( int i = mzStartIdx; i <= mzEndIdx + 1; i++ ) {
        // get point
        double x = 0.0;
        double y = 0.0;
        if( i <= mzEndIdx ) {
            x = (double)pt.getX( i );
            y = (double)pt.getY( i );
        }
        else {
            x = std::max( m_tmp->maxMz, prevMz + 1.0 );
        }

        // get index
        int idx = roundnum( (double)( x - m_tmp->minMz ) / unitRange );

        // set intensity
        if( idx >= 0 && idx < size ) {
            if( idx == prevIdx ) {
                if( fabs( y ) > fabs( intensities[ idx ] ) ) {
                    intensities[ idx ] = y;
                }
            }
            else{
                intensities[ idx ] = y;
            }
        }

        // interpolation
        int sIdx = prevIdx + 1;
        sIdx = MAX( 0, sIdx );
        if( x <= prevMz + mzZeroRange ) {   // linear interpolation
            for( int j = sIdx; j < idx && j < size; j++ ) {
                double mz = m_tmp->minMz + (double)j * unitRange;

                double d1 = fabs( mz - prevMz );
                double d2 = fabs( x - mz );

                intensities[ j ] = ( d2 * prevInt + d1 * y ) / ( d1 + d2 );
            }
        }
        else {      // insert zero
            double zeroRange = std::min( ( x - prevMz ) / 2.5, mzZeroRange );

            for( int j = sIdx; j < idx && j < size; j++ ) {
                double mz = m_tmp->minMz + (double)j * unitRange;

                if( mz > x - zeroRange ) {
                    double d = mz - ( x - zeroRange );

                    intensities[ j ] = ( d * y ) / zeroRange;
                }
                else if( mz < prevMz + zeroRange ) {
                    double d = zeroRange - fabs( mz - prevMz );

                    intensities[ j ] = ( d * prevInt ) / zeroRange;
                }
                else {
                    intensities[ j ] = 0.0;
                }
            }
        }

        // previous
        prevIdx = idx;
        prevMz = x;
        prevInt = y;
    }
}

Here is the call graph for this function:

bool kome::objects::DataMapInfo::isAutoCommit

(

)

gets auto commit flag

Returns

auto commit flag

Definition at line 328 of file DataMapInfo.cpp.

                               {
    return m_autoCommit;
}

bool kome::objects::DataMapInfo::isCompleted

(

)

gets completed flag

Returns

completed flag value

Definition at line 143 of file DataMapInfo.cpp.

                              {
    return m_completed;
}

static bool kome::objects::DataMapInfo::lessSpec ( Spectrum *  spec0, Spectrum *  spec1  )

staticprotected

compare RT of spectrum to sort

Parameters

[in]	spec0	spectrum to be compared
[in]	spec1	spectrum to compare

Returns

If spec0 sorts before spec1, this method returns true.

Definition at line 762 of file DataMapInfo.cpp.

                                                             {
    return ( spec0->getRt() < spec1->getRt() );
}

Here is the call graph for this function:

bool kome::objects::DataMapInfo::loadDataMap

(

const char *

path

)

loads data map

Parameters

[in]

path

data map file path to load

Returns

If true, it succeeded to load data map

Definition at line 394 of file DataMapInfo.cpp.

                                                {
    // file open
    FILE* fp = fileopen( path, "rb" );
    if( fp == NULL ) {
        return false;
    }

    // array size
    const unsigned int size = m_row * m_col;

    // load array size
    unsigned int row = 0;
    unsigned int col = 0;

    fread( &row, sizeof( row ), 1, fp );
    fread( &col, sizeof( col ), 1, fp );

    if( row != m_row || col != m_col ) {
        LOG_WARN( FMT( "Data Map size is different." ) );
        fclose( fp );
        return false;
    }

    fread( &m_minMz, sizeof( m_minMz ), 1, fp );
    fread( &m_maxMz, sizeof( m_maxMz ), 1, fp );
    fread( &m_minRt, sizeof( m_minRt ), 1, fp );
    fread( &m_maxRt, sizeof( m_maxRt ), 1, fp );
    fread( &m_minIntensity, sizeof( m_minIntensity ), 1, fp );
    fread( &m_maxIntensity, sizeof( m_maxIntensity ), 1, fp );

    if( size > 0 ) {
        fread( m_map, sizeof( double ), size, fp );
    }

    fclose( fp );

    return true;
}

Here is the call graph for this function:

bool kome::objects::DataMapInfo::saveDataMap

(

const char *

path

)

saves data map

Parameters

[in]

path

data map file path to save

Returns

If true, it succeeded to save data map

Definition at line 363 of file DataMapInfo.cpp.

                                                {
    // file open
    FILE* fp = fileopen( path, "wb" );
    if( fp == NULL ) {
        return false;
    }

    // array size
    const unsigned int size = m_row * m_col;

    // save
    fwrite( &m_row, sizeof( m_row ), 1, fp );
    fwrite( &m_col, sizeof( m_col ), 1, fp );
    fwrite( &m_minMz, sizeof( m_minMz ), 1, fp );
    fwrite( &m_maxMz, sizeof( m_maxMz ), 1, fp );
    fwrite( &m_minRt, sizeof( m_minRt ), 1, fp );
    fwrite( &m_maxRt, sizeof( m_maxRt ), 1, fp );
    fwrite( &m_minIntensity, sizeof( m_minIntensity ), 1, fp );
    fwrite( &m_maxIntensity, sizeof( m_maxIntensity ), 1, fp );

    if( size > 0 ) {
        fwrite( m_map, sizeof( double ), size, fp );
    }

    fflush( fp );
    fclose( fp );

    return true;
}

Here is the call graph for this function:

void kome::objects::DataMapInfo::setAutoCommit

(

const bool

autoCommit

)

sets auto commit flag

Parameters

[in]

autoCommit

auto commit flag

Definition at line 323 of file DataMapInfo.cpp.

                                                       {
    m_autoCommit = autoCommit;
}

void kome::objects::DataMapInfo::setCompleted

(

const bool

completed

)

sets completed flag

Parameters

[in]

completed

completed flag value

Definition at line 138 of file DataMapInfo.cpp.

                                                     {
    m_completed = completed;
}

void kome::objects::DataMapInfo::setIntensityRange	(	const double	minInt,
		const double	maxInt
	)

sets intensity range

Parameters

[in]	minInt	min intensity
[in]	maxInt	max intensity

Definition at line 148 of file DataMapInfo.cpp.

                                                                              {
    m_minIntensity = minInt;
    m_maxIntensity = maxInt;
}

bool kome::objects::DataMapInfo::setRange	(	double	minMz,
		double	maxMz,
		double	minRt,
		double	maxRt,
		const char *	filterName,
		kome::core::Progress &	progress
	)

sets data map range

Parameters

[in]	minMz	min m/z (If negative value, it uses default value instead.)
[in]	maxMz	max m/z (If negative value, it uses default value instead.)
[in]	minRt	min m/z (If negative value, it uses default value instead.)
[in]	maxRt	max m/z (If negative value, it uses default value instead.)
[in]	filterName	filter name
[out]	progress	the object to show progress

Returns

If true, map is created completly.

Definition at line 194 of file DataMapInfo.cpp.

  {
    // @date 2012.09.07 <Mod> M.Izumi ->
    std::vector< kome::objects::Spectrum* > tmpSpecArray;
    getSpecArray( filterName, tmpSpecArray );
    // @date 2012.09.07 <Mod> M.Izumi <-

    int specNum = (int)tmpSpecArray.size();

    // start index
    int startIdx = 0;
    if( minRt >= 0.0 ) {
        for( int i = 0; i < specNum; i++ ) {
            if( tmpSpecArray[ i ]->getRt() <= minRt ) {
                startIdx = i;
            }
        }
    }

    // end index
    int endIdx = specNum - 1;
    if( maxRt >= 0.0 ) {
        for( int i = specNum - 1; i >= 0; i-- ) {
            if( tmpSpecArray[ i ]->getRt() >= maxRt ) {
                endIdx = i;
            }
        }
    }

    int length = endIdx - startIdx + 1;

    // spectra
    std::vector< kome::objects::Spectrum* > specArray;
    for( int i = startIdx; i <= endIdx; i++ ) {
        specArray.push_back( tmpSpecArray[ i ] );
    }

    // check the data
    if( length <= 0 ) {     // There is no spectrum.
        // set value
        m_tmp->minMz = MAX( minMz, 0.0 );
        m_tmp->maxMz = MAX( maxMz, 0.1 );
        m_tmp->minRt = MAX( minRt, 0.0 );
        m_tmp->maxRt = MAX( maxRt, 0.1 );
        m_tmp->minIntensity = 0.0;
        m_tmp->maxIntensity = 0.0;

        // progress
        progress.setRange( 0, 1 );
        progress.setPosition( 1 );

        // commit
        if( m_autoCommit ) {
            commit();
        }

        // flag
        m_completed = true;

        return true;
    }

    // rt   
    m_tmp->minRt = minRt < 0.0 ? tmpSpecArray[ startIdx ]->getRt() : minRt;
    m_tmp->maxRt = maxRt < 0.0 ? tmpSpecArray[ endIdx ]->getRt() : maxRt;

    // progress range
    progress.setRange( 0, 6 * length );
    progress.setPosition( 0 );

    // min m/z
    if( minMz < 0.0 ) {
        minMz = tmpSpecArray[ startIdx ]->getMinX();

        for( int i = startIdx + 1; i <= endIdx && !progress.isStopped(); i++ ) {
            progress.setPosition( i - startIdx );
            minMz = MIN( minMz, tmpSpecArray[ i ]->getMinX() );
        }
    }
    progress.setPosition( length );

    // max m/z
    if( maxMz < 0.0 ) {
        maxMz = tmpSpecArray[ startIdx ]->getMaxX();

        for( int i = startIdx + 1; i < endIdx && !progress.isStopped(); i++ ) {
            progress.setPosition( length + i - startIdx );
            maxMz = MAX( maxMz, tmpSpecArray[ i ]->getMaxX() );
        }
    }

    if( !progress.isStopped() ) {
        progress.setPosition( 2 * length );

        m_tmp->minMz = MIN( maxMz, minMz );
        m_tmp->maxMz = MAX( maxMz, minMz );
        double midMz = ( m_tmp->minMz + m_tmp->maxMz ) / 2.0;
        m_tmp->minMz = std::min( midMz - 0.01, m_tmp->minMz );
        m_tmp->maxMz = std::max( midMz + 0.01, m_tmp->maxMz );
    }

    // create image map
    if( !progress.isStopped() ) {
        createImageMap( specArray, progress );
    }

    // restore
    if( progress.isStopped() ) {
        rollback();
    }

    // commit
    if( m_autoCommit ) {
        commit();
    }

    // flag
    m_completed = !progress.isStopped();

    return m_completed;
}

Here is the call graph for this function:

Member Data Documentation

bool kome::objects::DataMapInfo::m_autoCommit

protected

auto commit flag

Definition at line 93 of file DataMapInfo.h.

unsigned int kome::objects::DataMapInfo::m_col

protected

column size

Definition at line 52 of file DataMapInfo.h.

bool kome::objects::DataMapInfo::m_completed

protected

completed flag

Definition at line 73 of file DataMapInfo.h.

DataGroupNode* kome::objects::DataMapInfo::m_group

protected

raw data

Definition at line 54 of file DataMapInfo.h.

double* kome::objects::DataMapInfo::m_map

protected

data map

Definition at line 57 of file DataMapInfo.h.

double kome::objects::DataMapInfo::m_maxIntensity

protected

max intensity

Definition at line 70 of file DataMapInfo.h.

double kome::objects::DataMapInfo::m_maxMz

protected

max m/z

Definition at line 62 of file DataMapInfo.h.

double kome::objects::DataMapInfo::m_maxRt

protected

max RT

Definition at line 66 of file DataMapInfo.h.

double kome::objects::DataMapInfo::m_minIntensity

protected

min intensity

Definition at line 68 of file DataMapInfo.h.

double kome::objects::DataMapInfo::m_minMz

protected

min m/z

Definition at line 60 of file DataMapInfo.h.

double kome::objects::DataMapInfo::m_minRt

protected

min RT

Definition at line 64 of file DataMapInfo.h.

unsigned int kome::objects::DataMapInfo::m_row

protected

row size

Definition at line 50 of file DataMapInfo.h.

TmpData* kome::objects::DataMapInfo::m_tmp

protected

temporary data

Definition at line 90 of file DataMapInfo.h.

---

The documentation for this class was generated from the following files:

• DataObjects/DataMapInfo.h
• DataObjects/DataMapInfo.cpp