Pattern.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008 by Singularity Institute for Artificial Intelligence
 * Written by Joel Pitt <joel@fruitionnz.com>
 * All Rights Reserved
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License v3 as
 * published by the Free Software Foundation and including the exceptions
 * at http://opencog.org/wiki/Licenses
 *
 * 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 Affero General Public License
 * along with this program; if not, write to:
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef _OPENCOG_HDEMO_PATTERN_MATRIX_H
#define _OPENCOG_HDEMO_PATTERN_MATRIX_H

#include <vector>

#include <opencog/atomspace/AttentionValue.h>
#include <opencog/util/RandGen.h>

namespace opencog
{

extern RandGen* patternRng;

class Pattern : public std::vector< int >
{

private:
    // Height and width of pattern
    int width;
    int height;

    opencog::RandGen *rng;
    std::vector<bool> *mask;

public:

    Pattern(int w, int h, float density = 0.0f);

    Pattern(const Pattern &src) : std::vector<int>(src), 
        width(src.width), height(src.height), rng(patternRng), mask(NULL) {
            if (src.mask) mask = new std::vector<bool>(*(src.mask));
        };

    ~Pattern();

    Pattern & operator = (const Pattern & other) {
        if (this != &other) {
            // protect against invalid self-assignment
            width = other.width;
            height = other.height;
            rng = patternRng;
            mask = NULL;
            if (other.mask) mask = new std::vector<bool>(*(other.mask));
            std::vector<int>::operator=(other);
        }
        return *this;
    }

    float hammingSimilarity(const Pattern &p);

    int bitErrors(const Pattern &p);
    
    Pattern binarisePattern(AttentionValue::sti_t threshold);

    Pattern mutatePattern(float error);

    Pattern mutatePattern(unsigned int error);

    int getWidth();
    int getHeight();
    bool isEmpty();
    void setMask(const std::vector<bool>& _mask);
    bool isMasked(uint i) const;

    int activity();

    static std::vector< Pattern > generateRandomPatterns(int amount, int w, int h, float density);

    static std::vector< Pattern > mutatePatterns( std::vector< Pattern > &patterns, float error);

    static std::vector< Pattern > loadPatterns( std::string fn, int size);

    bool operator==(const Pattern& b) const;
};

} // namespace opencog

#endif // _OPENCOG_HDEMO_PATTERN_MATRIX_H