neuromanager/neuromanager/SpikeData.cpp

/* --------------------------------------------------------------------- */
/* NeuroManager - A spike train analysis tool                            */
/* Copyright (c) 2005-2006 RIKEN, Japan. All rights reserved.            */
/* http://satellite.sourceforge.jp/                                      */
/* --------------------------------------------------------------------- */
/* This program is free software; you can redistribute it and/or         */
/* modify it under the terms of the GNU General Public License           */
/* as published by the Free Software Foundation; either version 2        */
/* of the License, or (at your option) any later version.                */
/*                                                                       */
/* This program is distributed in the hope that it will be useful,       */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of        */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         */
/* GNU General Public License for more details.                          */
/*                                                                       */
/* You should have received a copy of the GNU General Public License     */
/* along with this program; see the file COPYING.txt. If not, write      */
/* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth      */
/* Floor, Boston, MA 02110-1301, USA.                                    */
/* --------------------------------------------------------------------- */

/* $Id: SpikeData.cpp,v 1.1 2006/02/04 13:38:16 orrisroot Exp $ */

// SpikeData.cpp : implementation of the CSpikeData class
//

#include "stdafx.h"
#include "SpikeData.h"

CSpikeData::CSpikeData()
{
        m_pMCData = NULL;
        m_iChannelNumber = -1;
        m_uDataSize = 0;
        m_nWidth = 0;
        m_pqwDataPos = NULL;
        m_pdData = NULL;
        m_piComponent = NULL;
}

CSpikeData::~CSpikeData()
{
        if ( m_uDataSize > 0 )
        {
                // free memory
                delete [] m_pqwDataPos;
                for ( UINT i = 0; i < m_uDataSize; i++ )
                        delete [] m_pdData[ i ];
                delete [] m_pdData;
                delete [] m_piComponent;
        }
}

int CSpikeData::GetChannelNumber()
{
        ASSERT( m_pMCData != NULL );
        return m_iChannelNumber;
}

UINT CSpikeData::GetSize()
{
        ASSERT( m_pMCData != NULL );
        return m_uDataSize;
}

SIZE_T CSpikeData::GetWidth()
{
        ASSERT( m_pMCData != NULL );
        return m_nWidth;
}

QWORD CSpikeData::GetDataPos( UINT num )
{
        ASSERT( m_pMCData != NULL );
        ASSERT( m_uDataSize > num );
        return m_pqwDataPos[ num ];
}

double **CSpikeData::GetParsedData()
{
        ASSERT( m_pMCData != NULL );
        ASSERT( m_uDataSize > 0 );
        return m_pdData;
}

BOOL CSpikeData::Initialize( CMultiChannelData *pMCData, UINT ch )
{
        ASSERT( pMCData != NULL );
        ASSERT( pMCData->IsMapped() );
        ASSERT( pMCData->GetChannelNumber() > ch );
        m_pMCData = pMCData;
        m_iChannelNumber = ch;
        return TRUE;
}

BOOL CSpikeData::SetWidth( SIZE_T width )
{
        ASSERT( m_pMCData != NULL );
        ASSERT( m_pMCData->IsMapped() );
        ASSERT( m_nWidth == 0 ); // must be zero
        m_nWidth = width;
        return TRUE;
}

BOOL CSpikeData::AddSpike( QWORD pos )
{
        ASSERT( m_pMCData != NULL );
        ASSERT( m_pMCData->IsMapped() );
        ASSERT( m_nWidth != 0 ); // must be already initialized spike width
        // allocate memory
        double *data_mem = new double[ m_nWidth ];
        double **data_array = new double * [ m_uDataSize + 1 ];
        QWORD *data_pos = new QWORD[ m_uDataSize + 1 ];
        int *comp_num = new int[ m_uDataSize + 1 ];
        SIZE_T len = m_nWidth;
        // get data from raw data file
        m_pMCData->AttachData( m_iChannelNumber );
        for ( SIZE_T i = 0; i < len; i++ )
                data_mem[ i ] = m_pMCData->GetData( pos + i );
        m_pMCData->DetachData();
        // set new data array to allocated memory
        for ( UINT i = 0; i < m_uDataSize; i++ )
        {
                data_array[ i ] = m_pdData[ i ];
                data_pos[ i ] = m_pqwDataPos[ i ];
                comp_num[ i ] = m_piComponent[ i ];
        }
        data_array[ m_uDataSize ] = data_mem;
        // free old memory
        if ( m_uDataSize > 0 )
        {
                delete [] m_pdData;
                delete [] m_pqwDataPos;
                delete [] m_piComponent;
        }
        // replace member variables
        m_pdData = data_array;
        m_pqwDataPos = data_pos;
        m_piComponent = comp_num;
        m_uDataSize++;
        return TRUE;
}
