map_tk.h

Go to the documentation of this file.

#ifndef _MAP_TK_H_
#define _MAP_TK_H_

/* Copyright (c) Kyriacos Leptos and the President and Fellows of Harvard University
   Release Date: 2004-11-01
   Part of the MapQuant suite library "massspec.lib"
*/

/* ************** DEFINE THE MAP (OR PATCH) DATA STRUCTURE ************* */

#define MAP_VALUE_NOT_SEGMENT FLT_MIN

extern float MAP2D_MAX_SIZE_IN_POINTS;

enum {REMOVE_EDGES, INCLUDE_EDGES};

enum { RT_DIMENSION, MZ_DIMENSION};

enum { MAP2D_X_AXIS_UNITS_SCANS, MAP2D_X_AXIS_UNITS_TIME};

enum { MAP2D_Y_AXIS_UNITS_PPM,
       MAP2D_Y_AXIS_UNITS_MZ_BINS,
       MAP2D_Y_AXIS_UNITS_MZ};

enum { MAP2D_POINT_INDEX,
       MAP2D_POINT_SAMPLING,
       MAP2D_POINT_REAL };

enum {  MAP2D_X_AXIS_MODE_MS_SCANS_ONLY,
        MAP2D_X_AXIS_MODE_ALL_SCANS };

enum {  MAP2D_Y_AXIS_MODE_NO_RULERS_LINEAR_MODEL,
        MAP2D_Y_AXIS_MODE_NO_RULERS_QUADRATIC_MODEL,
        MAP2D_Y_AXIS_MODE_ONE_RULER_WITHOUT_PROJECTION,
        MAP2D_Y_AXIS_MODE_ONE_RULER_WITH_PROJECTION,
        MAP2D_Y_AXIS_MODE_MULTIPLE_RULERS_WITHOUT_PROJECTION,
        MAP2D_Y_AXIS_MODE_MULTIPLE_RULERS_WITH_PROJECTION };

typedef struct Map2D Map2D;

struct Map2D
{
    unsigned isLoaded       : 1;
    unsigned isBinary       : 1;
    unsigned isMultiple     : 1;
    unsigned isTile         : 1;
    unsigned isSeam         : 1;

    unsigned isProcessed    : 1;
    unsigned isGrayscale    : 1;
    unsigned isDeconvolved  : 1;

    unsigned isMarked       : 1;
    unsigned isFitted       : 1;

    unsigned nScanMode      : 1;

    /* Segmentation info */
    unsigned isSegment      : 1;
    unsigned isOnEdge       : 1;

    unsigned isStatCalculated : 1;



    struct  MQSegmentAttributes*        pAttributes;
    int                     nAttributes;
    //int*                  pSegmentsOnEdge;
    //int                   nSegmentsOnEdge;



    struct Map2D*   parentMap;
    struct Map2D*   labeledMap;

    // ******** Universal Processing Identifiers ********
    // Filename and path location
    // MQExperiment pointer
    // MQExperiment's name
    // Rectangle  within experiment
    // Processing script
    // Processing script's name

    // Location

    char*       path;

    char*       name;

    // MQExperiment
    char*           experiment;
    MQExperiment*       expmnt;

    // Session
    char*           session;

    // Borders
    Insets4i        borders;

    // Processing Script
    char*           ps;
    ProcScript      procscript;

    // ********* END OF UNIVERSAL PROCESSING IDENTIFIERS ****

    // MSMS Info
    void* pMS2Data;
    int   nMS2Data;

    Insets4i*   pTiles;
    int             nTiles;
    MQTileID        bTile;

    MQDescriptiveStatistics stat;

    MQDimensions2i  dim;

    float*          rtsa;
    int*            scsa;

    float*          mssa;

    // Stat
    float           max;

    float**         abu;
} ;




// *************** MAP MEMORY ALLOCATION *******************

Map2D*  Map2D_new();


void Map2D_mallocAbundanceMatrix(Map2D* map);


void Map2D_mallocScanArray(Map2D* map);


void Map2D_mallocDim(Map2D* map, MQDimensions2i dim);


void Map2D_malloc(Map2D* map, int no_of_scans, int no_of_bins);


// ******************** INIT AND SETTING HEADER ************

void    Map2D_initHeader(Map2D* map);
void    Map2D_initAbundance(Map2D* map, float value);
int     Map2D_addValue(Map2D* map, int scan, int bin, float value);
void    Map2D_discardZeros(Map2D* map);
void    initMap(Map2D* MP);

void    Map2D_setScanMode(Map2D* map, int scan_mode);
int     Map2D_setExperiment(Map2D* map, MQExperiment* expmnt);
int     Map2D_setSize(Map2D* map, Insets4i* rect);
void    Map2D_setHeader(Map2D* map, MQExperiment* expmnt, Insets4i rect);
void    Map2D_setSamplingArrays(Map2D* map, Insets4i* rect);
void    Map2D_setBorders(Map2D* map, int x_start, int x_stop, int y_start, int y_stop);
void    Map2D_setProcScript(Map2D* map, ProcScript PS);
int     Map2D_fprintHeader(FILE* fp, Map2D* map);
void    Map2D_fprintAbundanceMatrix(FILE* fp, Map2D* map, int format);
void    Map2D_fprintAbundanceSubMatrix(FILE* fp, Map2D* map, Insets4i* rect);
void    Map2D_printHeader(Map2D *map, char* mapname);

// *************** COPY OPERATIONS ******************

void    Map2D_copyHeaderStatusBits(Map2D* dest, Map2D* source);
void    Map2D_copyHeader(Map2D* source, Map2D* dest);
void    Map2D_copy(Map2D* dest, Map2D* source);

// *************** MAP OPERATIONS *******************

void    Map2D_create(Map2D* map, MQExperiment* expmnt, Insets4i rect);
void    Map2D_createUsingTemplate(Map2D* output_map, Map2D* template_map, float init_value);
Map2D   Map2D_createBinaryMap(Map2D* map, float threshold);

void    Map2D_destroy(Map2D *map);

void    Map2D_invert_new(Map2D* out, Map2D* in);
float   Map2D_calcArea(Map2D* map);

float   Map2D_getResidualVolume(Map2D *original, Map2D *fitted);
void    Map2D_subtractMaps(Map2D *one, Map2D *two, Map2D *diff);
void    Map2D_mergeMaps(Map2D *one, Map2D *two, Map2D *result);

void    Map2D_applyLinearInterpolation(Map2D* map);
int     Map2D_applyErosion(Map2D *OMAP, Map2D *IMAP, char* szStructElemName);
int     Map2D_applyDilation(Map2D *OMAP, Map2D *IMAP, char* szStructElemName);
int     Map2D_applyClosing(Map2D *map, char* szStructElemName);
int     Map2D_applyClosingUsingOriginal(Map2D *out, Map2D *in, char* szStructElemName);
int     Map2D_applyOpening(Map2D *map, char* szStructElemName);


// ************ BOUNDARY CHECKING FUNCTIONS

int Map2D_isMOZValid(Map2D *map, float MOZ);
int Map2D_isRTValid(Map2D *map, float RT);

int Map2D_isMassBinValid(Map2D *map, int mass_bin);
int Map2D_isScanValid(Map2D *map, int rt_bin); // rt_bin = scan

int Map2D_isMassIndexValid(Map2D *map, int mass_index);
int Map2D_isRTIndexValid(Map2D *map, int rt_index);

// ************* MAP ROW && COLUMN OPERATIONS

enum { MASS_TYPE_MOZ, MASS_TYPE_BIN, MASS_TYPE_MZJ };
enum { RT_TYPE_MIN, RT_TYPE_SCAN, RT_TYPE_RTI };

float* Map2D_getAbundanceArrayFromMassChrm(Map2D *map, int size, float index_value, int index_type);
float* Map2D_getAbundanceArrayFromMassSpec(Map2D *map, int size, float index_value, int index_type);

float* Map2D_getAbundancePointerFromScan (Map2D* map, int scan);
float* Map2D_getAbundancePointerFromIndex(Map2D* map, int scanIndex);

float* getAbundanceArrayOfMassSpecAtRTI(Map2D *map, int rt_index,
                                                   int start,
                                                   int stop);

void   putMassChrmToMap2D_BIN(Map2D* MP, int bin,      float* array, int size);
void   putMassChrmToMap2D_MZI(Map2D* MP, int mz_index, float* array, int size);

void   Map2D_transferFloatArrayAsMassSpecIndex(Map2D *map, float* array, int size2, int rt_index);

Map2D Map2D_extractSubMap(Map2D* map, Insets4i* rect);

// ************* SAMPLING ARRAY OPERATIONS

float* getRTSamplingArrayFromMap2D(Map2D* MP);
float* getMSSamplingArrayFromMap2D(Map2D* MP);

/* ******************************************************************** */

void    Map2D_transformPeak2i           (Map2D* map, Peak2i* peak, int type);
void    Map2D_transformPeak2iArray(Map2D* map, Peak2i* peaks, int npeaks, int type);
void    Map2D_transformBorders(Map2D* map, Insets4i* target, int type);

float   Map2D_getValueReal(Map2D *map, float rt, float mz);
float   Map2D_getValue                  (Map2D *map , Peak2i peak);

void    Peak2i_fprintlnWithMapValue    (FILE* fp, Peak2i peak, Map2D* map);
void    Peak2i_fprintlnWithMapValues   (FILE* fp, Peak2i peak, Map2D* map);
void    Peak2iArray_fprintWithMapValues(FILE* fp, Peak2i* peaks, int start, int stop, Map2D* map);
void    Peak2iArray_fprintWithMapValue (FILE* fp, Peak2i* peaks, int start, int stop, struct Map2D* map);

int     Map2D_getIndexFromScan   (Map2D *map, int scan);
int     Map2D_getIndexFromMassBin(Map2D *map, int bin);

int     Map2D_getIndexFromRT(Map2D* map, float RT);
int     Map2D_getIndexFromMOZ(Map2D* map, float MOZ);

int     Map2D_getScanFromIndex   (Map2D* map, int index);
int     Map2D_getMassBinFromIndex(Map2D* map, int binIndex);

float   Map2D_getFloatScanFromIndex(Map2D* map, int scanIndex);
float   Map2D_getFloatMassBinFromIndex(Map2D* map, int binIndex);

float   Map2D_getRTFromScan(Map2D* map, int scanNumber);
float   Map2D_getMOZFromMassBin(Map2D* map, int binNumber);

float   Map2D_getRTFromIndex(Map2D* map, int scanIndex);
float   Map2D_getMOZFromIndex(Map2D* map, int binIndex);

int     Map2D_findHighestIntensityScan(Map2D* map);
void    Map2D_findMinMax(Map2D *map, float* max, float* min);
void    Map2D_findMinMaxMultiple(MQExperiment* expmnt, char* szSession, char* type, float* max, float* min);
int*    Map2D_getHistogramMultiple(MQExperiment* expmnt, char* szSession, char* type, float max, int* nbins);
int*    Map2D_getHistogram(Map2D* map,  float max, int* nBinSize, int* nbins);
int     Map2D_getNumberOfSegmentsMultiple(MQExperiment* expmnt, char* szSessionName);

struct Segment* Map2D_getSegmentArray(Map2D* map, int  nMode, int* nSegment);

void Map2D_saveRawInfo(char* szPath, char* szMap2D, Map2D* map);

int     Map2D_isPeakInMap(Map2D* map, int scan, int bin);
float*  Map2D_collapseToTIC(Map2D* map, int* nSize);
int     Map2D_alignMaps(Map2D* map1, Map2D* map2 /* map to be superimposed */);

void    Map2D_trimEdges(Map2D* map, float value);
void    Map2D_eliminateNegativeValues(Map2D* map);

void    Map2D_tile(Map2D* map, float mz_width);
void    Map2D_tileUsingSize(Map2D* map, float tile_size);

Peak3iif* Map2D_getPeak3iifArray(Map2D* MAP, int* npeaks, int type);

int Map2D_deconvolveUsingWienerFilter(Map2D* pMap, float dSD, int nDimension,
                                      int signal_scan, int noisy_scan);

int Map2D_deconvolve(Map2D* pMap, float dSD, int nDimension);
int Map2D_getStatFromMassChrm(Map2D *map, int index_type, void* index_value, MQDescriptiveStatistics* stat);
int Map2D_getStatFromMassSpec(Map2D *map, int index_type, void* index_value, MQDescriptiveStatistics* stat);

int Map2D_loadMS2Data(Map2D* map, MQExperiment* ms2_expmnt);

/* ***************************** Calculate Statistics for Map2D ***************************** */

int   Map2D_calcDescriptiveStatistics(Map2D* map, int mode);
float Map2D_getMeanAbundanceValue(Map2D* map, int mode);
float Map2D_getMedianAbundanceValue(Map2D* map, int mode);
float Map2D_getStandardDeviationOfAbundanceValues(Map2D* map, float mean, int mode);
float Map2D_getMADM(Map2D* map, float median, int mode);
float Map2D_getAADM(Map2D* map, float median, int mode);

int   Map2D_calcDescriptiveStatisticsForInsets4i(Map2D* map, Insets4i* borders, int mode);
float Map2D_getMeanAbundanceValueForInsets4i(Map2D* map, Insets4i* borders, int mode);
float Map2D_getMedianAbundanceValueForInsets4i(Map2D* map, Insets4i* borders, int mode);
float Map2D_getMADMForInsets4i(Map2D* map, Insets4i* borders, float median, int mode);
float Map2D_getAADMForInsets4i(Map2D* map, Insets4i* borders, float median, int mode);

/* ******************************************************************************************* */

float Map2D_calcMeanRTSamplingTime(Map2D* map);
float Map2D_calcMeanMZSamplingTime(Map2D* map);

int Map2D_isMassSpecSignalConstant(Map2D *map, int index_type, void* index_value);

BaselineMark            Map2D_getBaselineForPeak(Map2D* map, Peak2i* peak, int dimension);
BaselineMark*           Map2D_getBaselineForPeak2iArray(Map2D* map, Peak2i* peakarray, int nsize, int dimension);
void                    Map2D_getPeakEndsInRT(Map2D* map, int scan, int bin, int* left, int* right);

void Map2DArray_merge(Map2D *array, int size, Map2D *result);

#endif

---