Ejemplo n.º 1
0
ParseTree::ParseTree(const ParseTree & pt) :
    g_(NULL), idxRootNode_(-1), states_(NULL), dataId_(pt.dataId()),
    appearanceX_(NULL), imgWd_(pt.imgWd()), imgHt_(pt.imgHt())
{
    nodeSet_.resize(pt.nodeSet().size(), NULL);
    for ( int i = 0; i < nodeSet_.size(); ++i ) {
        nodeSet_[i] = new PtNode(*pt.nodeSet()[i]);
    }

    edgeSet_.resize(pt.edgeSet().size(), NULL);
    for ( int i = 0; i < edgeSet_.size(); ++i ) {
        edgeSet_[i] = new PtEdge(*pt.edgeSet()[i]);
    }

    idxRootNode_ = pt.idxRootNode();

    g_ = pt.grammar();

    appearanceSet_.resize(pt.appearanceSet().size(), NULL);
    for ( int i = 0; i < appearanceSet_.size(); ++i ) {
        appearanceSet_[i] = new Appearance::Param(*pt.appearanceSet()[i]);
    }

    biasSet_ = pt.biasSet();

    deformationSet_.resize(pt.deformationSet().size(), NULL);
    for ( int i = 0; i < deformationSet_.size(); ++i ) {
        deformationSet_[i] = new Deformation::Param(*pt.deformationSet()[i]);
    }

    scalepriorSet_.resize(pt.scalepriorSet().size(), NULL);
    for ( int i = 0; i < scalepriorSet_.size(); ++i ) {
        scalepriorSet_[i] = new Scaleprior::Param(*pt.scalepriorSet()[i]);
    }

    parseInfoSet_.resize(pt.parseInfoSet().size(), NULL);
    for ( int i = 0; i < parseInfoSet_.size(); ++i ) {
        parseInfoSet_[i] = new ParseInfo(*pt.parseInfoSet()[i]);
    }

    if (pt.states() != NULL ) {
        states_ = new States(*pt.states());
    }

    appUsage_ = pt.appUsage();

    if ( pt.appearaceX() != NULL ) {
        appearanceX_ = new Appearance::Param( *(pt.appearaceX()) );
    }

}
Ejemplo n.º 2
0
int ParseTree::compareFeatures(const ParseTree & pt) const
{
    assert(grammar() != NULL && grammar() == pt.grammar() );

    for ( int i = 0;  i < nodeSet().size(); ++i ) {
        int idxG = nodeSet()[i]->idx()(PtNode::IDX_G);

        int ii = 0;
        for ( ; ii < pt.nodeSet().size(); ++ii ) {
            int idxG1 = pt.nodeSet()[ii]->idx()(PtNode::IDX_G);
            if ( idxG1 == idxG ) {
                break;
            }
        } // for ii

        if ( ii == pt.nodeSet().size() ) {
            return 1;
        }

        for ( int j = PtNode::IDX_BIAS; j < PtNode::IDX_APP+1; ++j ) {
            int fidx  = nodeSet()[i]->idx()(j);
            int fidx1 = pt.nodeSet()[ii]->idx()(j);
            if (fidx != -1 && fidx1 != -1 ) {
                switch (j) {
                case PtNode::IDX_BIAS: {
                    if ( biasSet()[fidx] > pt.biasSet()[fidx1] ) {
                        return 1;
                    } else if ( biasSet()[fidx] < pt.biasSet()[fidx1] ) {
                        return -1;
                    }

                    break;
                }
                case PtNode::IDX_DEF: {
                    const Deformation::Param & p(*deformationSet()[fidx]);
                    const Deformation::Param & p1(*pt.deformationSet()[fidx1]);
                    for ( int k = 0; k < 4; ++k ) {
                        if ( p(k) > p1(k) ) {
                            return 1;
                        } else if (p(k) < p1(k)) {
                            return -1;
                        }
                    }
                    break;
                }
                case PtNode::IDX_SCALEPRIOR: {
                    const Scaleprior::Param & p(*scalepriorSet()[fidx]);
                    const Scaleprior::Param & p1(*pt.scalepriorSet()[fidx1]);
                    for ( int k = 0; k < 3; ++k ) {
                        if ( p(k) > p1(k) ) {
                            return 1;
                        } else if (p(k) < p1(k)) {
                            return -1;
                        }
                    }
                    break;
                }
                case PtNode::IDX_APP: {
                    const Appearance::Param & p(*appearanceSet()[fidx]);
                    const Appearance::Param & p1(*pt.appearanceSet()[fidx1]);
                    for ( int row=0; row < p.rows(); ++ row )
                        for ( int col=0; col < p.cols(); ++col )
                            for ( int k = 0; k < FeaturePyramid::NbFeatures; ++k ) {
                                if ( p(row, col)(k) > p1(row, col)(k) ) {
                                    return 1;
                                } else if (p(row, col)(k) < p1(row, col)(k)) {
                                    return -1;
                                }
                            }
                    break;
                }
                }
            } else {
                if (fidx != -1 && fidx1 == -1) {
                    return 1;
                }

                if (fidx == -1 && fidx1 != -1) {
                    return -1;
                }
            }
        }

    } // for i

    return 0;
}
Ejemplo n.º 3
0
void ParseTree::swap(ParseTree & pt)
{
    if ( this == &pt ) {
        return;
    }

    clear();

    nodeSet_.swap(pt.getNodeSet());

    edgeSet_.swap(pt.getEdgeSet());

    /*nodeSet_.resize(pt.nodeSet().size(), NULL);
    for ( int i = 0; i < nodeSet_.size(); ++i ) {
    	nodeSet_[i] = new PtNode(*pt.nodeSet()[i]);
    }

    edgeSet_.resize(pt.edgeSet().size(), NULL);
    for ( int i = 0; i < edgeSet_.size(); ++i ) {
    	edgeSet_[i] = new PtEdge(*pt.edgeSet()[i]);
    }*/

    idxRootNode_ = pt.idxRootNode();

    g_ = pt.grammar();

    appearanceSet_.swap(pt.getAppearanceSet());
    biasSet_.swap(pt.getBiasSet());
    deformationSet_.swap(pt.getDeformationSet());
    scalepriorSet_.swap(pt.getScalepriorSet());
    parseInfoSet_.swap(pt.getParseInfoSet());
    appUsage_.swap(pt.getAppUsage());

    /*appearanceSet_.resize(pt.appearanceSet().size(), NULL);
    for ( int i = 0; i < appearanceSet_.size(); ++i ) {
    	appearanceSet_[i] = new Appearance::Param(*pt.appearanceSet()[i]);
    }

    biasSet_ = pt.biasSet();

    deformationSet_.resize(pt.deformationSet().size(), NULL);
    for ( int i = 0; i < deformationSet_.size(); ++i ) {
    	deformationSet_[i] = new Deformation::Param(*pt.deformationSet()[i]);
    }

    scalepriorSet_.resize(pt.scalepriorSet().size(), NULL);
    for ( int i = 0; i < scalepriorSet_.size(); ++i ) {
    	scalepriorSet_[i] = new Scaleprior::Param(*pt.scalepriorSet()[i]);
    }

    parseInfoSet_.resize(pt.parseInfoSet().size(), NULL);
    for ( int i = 0; i < parseInfoSet_.size(); ++i ) {
    	parseInfoSet_[i] = new ParseInfo(*pt.parseInfoSet()[i]);
    }

    appUsage_ = pt.appUsage();*/

    if (pt.states() != NULL ) {
        //states_ = new States(*pt.states());
        std::swap(states_, pt.getStates());
    }

    dataId_ = pt.dataId();

    if ( pt.appearaceX() != NULL ) {
        std::swap(appearanceX_, pt.getAppearaceX());
    }

    imgWd_ = pt.imgWd();
    imgHt_ = pt.imgHt();
}