|| ||           || Doxygen's  

---

HxIndxArray.h

/*
 *  Copyright (c) 2000, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Jan-Mark Geusebroek (mark@wins.uva.nl)
 *
 */

/*
 *  JV, 06Mar03: added at+getKey function for random access to data
 */

#ifndef HxIndxArray_H
#define HxIndxArray_H

#include <stdio.h>
#include <list>
#include "HxMatrix.h"


template<class ArrayT, class HeaderT>
class indexedArray {
public:
    indexedArray();
    ~indexedArray();

    void open(HxString indexFile, int norm = 0);
    void close();
    void append(HxString indexFile);
    void create(HxString indexFile);
    void setHeader(HeaderT& header)
        {_header = header;}
        // should be called after create, before the first add

    HeaderT     header() const {return _header;}

    int         size() const {return _key.size();}

    virtual int arraySize(const HeaderT& header) const = 0;
    virtual double compare(ArrayT *e1, ArrayT *e2,
        const HeaderT& header) const = 0;

    void        add(HxString& key, ArrayT *data);

    ArrayT*     getData(HxString key) const;

    void        random(int n);
    void        search(ArrayT *target, int n, int refine = 0);
    void        retrieve(HxString key, int n, int refine = 0);
    HxString    nearest(int n) const;
    double      score(int n) const;
    ArrayT*     nearestData(int n) const;

    HxMatrix    similarity() const;
    STD_OSTREAM& put(STD_OSTREAM& os) const;

    void        import(STD_ISTREAM& is);

        /* Returns the data for the ndx-th element. */
    ArrayT*     at(int ndx) const;
    
        /* Returns the key of the ndx-th element. */
    HxString    getKey(int ndx) const;

    friend STD_OSTREAM& operator<<(STD_OSTREAM& os,
            const indexedArray<ArrayT, HeaderT>& l)
                {return l.put(os);}


private:
    HeaderT     _header;
    HxString     _fileName;

    FILE        *_fp;
    char        *_mem;

    int         _arraySize;

    std::list<ArrayT*>   _arrays;
    std::list<char*>        _key;

    double      *_nearval;
    char        **_nearkey;
    ArrayT      **_neardata;

    int         _normalize;
    ArrayT      *_minVal;
    ArrayT      *_normVal;
};

class indexedFloatArray : public indexedArray<float, int>  {
    int         arraySize(const int& header) const
                    {return header;}
    double      compare(float *e1, float *e2, const int& size) const
                    {
                        double norm2 = 0.0;
                        double v;

                        for (int i = size; i > 0; i--) {
                            v = *e1++ - *e2++;
                            norm2 += v*v;
                        }

                        return sqrt(norm2);
                    }
};

#ifdef INC_TEMPLATE_SRC
#include "HxIndxArray.c"
#endif

#endif

---