GRSpaceForceFunction.h

/*
  GUIDO Library
  Copyright (C) 2002  Holger Hoos, Juergen Kilian, Kai Renz
  Copyright (C) 2002-2017 Grame
 
  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
  Grame Research Laboratory, 11, cours de Verdun Gensoul 69002 Lyon - France
  research@grame.fr
 
*/
 
#ifndef __GRSPF_H
#define __GRSPF_H
 
#ifdef OLDSPFACTIVE
 
// for the hash-table.
#include "KR_Hash.h"
#include "KF_IList.h"
#include "GRSpring.h"
 
 
// already defined in GRSpringForceIndex.h 
// const float optimumforce = 600;
 
typedef KF_IPointerList<GRSpring> SpringList;
class GRConstraint;
 
typedef KF_IPointerList<GRConstraint>
    ConstraintList;
 
class ofstream;
 
class GRConstraint
{
public:
        int start;
        int end;
        double value;
        GRConstraint(int pstart,int pend,double pvalue)
        {
            start = pstart;
            end  = pend;
            value = pvalue;
        }
        GRConstraint(const GRConstraint &ct)
        {
            start = ct.start;
            end = ct.end;
            value = ct.value;
        }
        int operator==(const GRConstraint &ct)
        {
            if (start == ct.start
                && end == ct.end
                && value == ct.value)
                return 1;
            return 0;
        }
};
 
class GRSpaceForceFunction
{
public:
 
    class GRHashEntry   
    {
    
        friend class GRSpaceForceFunction;
        float extent;
        SpringList *sprlst;
 
    public:
        GRHashEntry()
        {
            sprlst = new SpringList(0);
        }
        virtual ~GRHashEntry()
        {
            delete sprlst;
        }
 
        GRHashEntry & operator=(const GRHashEntry &he)
        {
            delete sprlst;
            extent = he.extent;
            sprlst = new SpringList(*he.sprlst,0);
 
            return *this;
        }
 
 
        // the copy-constructor
        GRHashEntry(const GRHashEntry &he)
            
        {
            extent = he.extent;
            sprlst = new SpringList(*he.sprlst,0);
        }
    };
 
public:
    GRSpring *getGRSpring(int id);
    int addConstraint(int start,int end,double value);
    int getMatrixRealSize();
    int getMatrixMemSize();
    double * getMatrix();
    double * resizeMatrix(int newrealsize);
 
    int getMSCMatrixRealSize();
    int getMSCMatrixMemSize();
    double * getMSCMatrix();
 
    double getMSCMatrix(int i,int j) const;
    void setMSCMatrix(int i,int j,double value);
 
    double * resizeMSCMatrix(int newrealsize);
 
    float zconstdenom;
    GRSpaceForceFunction(const GRSpaceForceFunction &spf);
    float EvaluateBreak(float extent);
    float getOptimumForce(float sprconst);
    void UnfreezeSpring(GRSpring *spr);
    void FreezeSpring(GRSpring *spr);
    void ResetSprings();
    void CopySPFWithoutSprings(const GRSpaceForceFunction &spf);
    void addSPF(const GRSpaceForceFunction &spf);
 
    GRSpaceForceFunction();
    virtual ~GRSpaceForceFunction();
 
    void addSpring(GRSpring *spr);
    void deleteSpring(GRSpring *spr);
    void changeSpringForce(GRSpring *spr,float newforce);
    float getExtent(float force) const;
    float getForce(float extent,
        ofstream *springlog = NULL);
 
private:
 
    KR_HashTable<float,GRHashEntry> *hash;
 
    
 
protected:
    float forceret;
    float forceextent;
    float evalextent;
    float evalret;
    float zconstnum;
    // the freezeoffset is a number
    // that must be used to calculate
    // the extent/force, when
    // some springs in the Space-Force-Function
    // are frozen.
    // it offsets the base-coordinate-point
    // by the amount of the spring-extent.
    float freezeoffset;
 
    int matmemsize;
    int matrealsize;
    double *mat;
 
    int mscmatmemsize;
    int mscmatrealsize;
    double *mscmat;
 
 
    // this is for QP-Programming (solving the
    // spring-equation as energy-minimizing)
    ConstraintList cl;
 
};
 
#endif // ifdef OLDSPFACTIVE
 
#endif