Home Research Papers Posters Manuals Talks Download People Help Internal

libs/ck-libs/liveViz3d/ckviewable.h

Go to the documentation of this file.

/*
Describes a 3d object that can be "viewed"-- that is,
converted into a texture map.

Orion Sky Lawlor, olawlor@acm.org, 8/28/2002
*/
#ifndef __UIUC_PPL_CHARM_VIEWABLE_H
#define __UIUC_PPL_CHARM_VIEWABLE_H

#include "charm.h"
#include "ckvector3d.h"
#include "ckimage.h"
#include "ckviewpoint.h"
#include "ckhashtable.h"

class CkViewableID {
public:
    enum {nId=4};
    int id[nId];
    
    CkViewableID() {for (int i=0;i<nId;i++) id[i]=0;}
    CkViewableID(int len,const int *src) {
        int i;
        for (i=0;i<len;i++) id[i]=src[i];
        for (i=len;i<nId;i++) id[i]=0;
    }
    
    //Allows ViewableID's to be used in a hashtable:
    inline unsigned int hash(void) const {
        return id[0]+(id[1]<<8)+(id[2]<<16)+(id[3]<<24);
    }
    inline int compare(const CkViewableID &v) const {
        for (int i=0;i<nId;i++) if (id[i]!=v.id[i]) return 0;
        return 1;
    }
    static unsigned int staticHash(const void *key,size_t keyLen) {
        return ((const CkViewableID *)key)->hash();
    }
    static int staticCompare(const void *a,const void *b,size_t keyLen) {
        return ((const CkViewableID *)a)->compare(*(const CkViewableID *)b);
    }
    
    void pup(PUP::er &p) {
        p(id,nId);
    }
};
PUPmarshall(CkViewableID)


class CkReferenceCounted {
    int refCount;
protected:
    virtual ~CkReferenceCounted();
public:
    CkReferenceCounted() { refCount=1; }
    
    inline void ref(void) {refCount++;}
    
    inline void unref(void) {
        refCount--;
        if (refCount<0) CkAbort("Trying to unref deleted object!\n");
        if (refCount==0) delete this;
    }
};


/***************** Abstract Interface **************/

class CkView : public PUP::able, public CkReferenceCounted {
public:
    CkViewableID id;
    const CkViewableID &getViewable(void) const {return id;}
    
    unsigned int prio;
    
    int pixels;
    
    PUPable_abstract(CkView);
    
    virtual void pup(PUP::er &p);
    
    virtual void render(double alpha,CkView *old) =0;
};

void CkViewNodeInit(void);

class CkViewable {
public:
    CkViewable() :priorityAdjust(0) {}
    virtual ~CkViewable();

    int priorityAdjust;
    
    virtual bool shouldRender(const CkViewpoint &univ2screen,const CkView &oldView) =0;
    
    virtual CkView *renderView(const CkViewpoint &univ2screen) =0;
    
    virtual double getSize(const CkViewpoint &univ2screen);
};

class CkViewConsumer {
public:
    virtual ~CkViewConsumer();
    
    virtual void add(CkView *view) =0;
};

/***************** Basic Implementations **************/

class oglLilTex; // Forward declaration-- defined in ogl/liltex.h on client

class CkImageCompressor {
    // source/destination image
    CkAllocImage *img;
public:
    int w,h; 
    int gl_w, gl_h; 
    CkImageCompressor(CkAllocImage *img_) 
        :img(img_),w(img->getWidth()), h(img->getHeight()), gl_w(0), gl_h(0) { }
    void pup(PUP::er &p);
    CkAllocImage *getImage(void) {
        CkAllocImage *i=img;
        img=NULL;
        return i;
    }
};

class CkQuadView : public CkView {
public:
    enum {maxCorners=8};
    int nCorners;
    CkVector3d corners[maxCorners]; // xyz vertices
    CkVector3d texCoord[maxCorners]; // texture coordinates

// (CLIENT AND SERVER)
    virtual void pup(PUP::er &p);
    PUPable_decl(CkQuadView);
    virtual ~CkQuadView();
    
// (SERVER ONLY)
private:
    CkAllocImage s_tex;
    CkImageCompressor x_tex;
public:
    CkQuadView(int w,int h,int n_colors);
    
    CkAllocImage &getImage(void) {return s_tex;}
    const CkAllocImage &getImage(void) const {return s_tex;}

// (CLIENT ONLY)
private:
    oglLilTex *c_tex;
    void render(void);
public:
    CkQuadView(CkMigrateMessage *m);
    
    inline const oglLilTex *getTexture(void) const {return c_tex;}
    virtual void render(double alpha,CkView *old);
};


class CkFixedViewable : public CkViewable {
    CkView *v;
public:
    CkFixedViewable(CkView *v_) :v(v_) {v->ref();}
    ~CkFixedViewable() {v->unref();}
    
    // We never need to redraw:
    virtual bool shouldRender(const CkViewpoint &univ2screen,const CkView &oldView)
    {   
        return false;
    }
    // "rendering" just means returning our fixed CkView.
    virtual CkView *renderView(const CkViewpoint &univ2screen) {
        v->ref(); // semantics of return operation
        return v;
    }
};

/***************** Implementations based on Interest Points **************/

class CkInterestSet {
    enum {maxInterest=8};
    int nInterest; //Number of points below:
    CkVector3d loc[maxInterest]; //Locations of interest points

public:
    CkInterestSet(void) {nInterest=0;}
    CkInterestSet(int nInterest_,const CkVector3d *loc_);
    CkInterestSet(const CkBbox3d &box);
    
    int size(void) const {return nInterest;}
    const CkVector3d &operator[] (int i) const {return loc[i];}
    
    void setPoints(int n) {nInterest=n;}
    CkVector3d &operator[] (int i) {return loc[i];}
    
    CkBbox3d getBox(void) const {
        CkBbox3d box; box.empty();
        for (int i=0;i<nInterest;i++) box.add(loc[i]);
        return box;
    }
    
    CkVector3d getMean(void) const;
    
    void pup(PUP::er &p);
};
PUPmarshall(CkInterestSet)









class CkInterestView : public CkQuadView {
    //These are the true universe locations of our interest points:
    CkInterestSet univ;
    //These are the texture-projected locations of the interest points:
    CkInterestSet proj;
    CkVector3d projC,projX,projY;

    //Return the squared projection error (pixels) of point i:
    double sqrError(int i,const CkViewpoint &univ2screen) const
    {
        return univ2screen.project_noz(univ[i]) .distSqr(
               univ2screen.project_noz(proj[i]) );
    }
public:
    CkInterestView(int w,int h,int n_colors,
        const CkInterestSet &univ_,
        const CkViewpoint &univ2texture);
    
    double resRatio(const CkViewpoint &univ2screen) const;
    
    double rmsError(const CkViewpoint &univ2screen) const;
    
    double maxError(const CkViewpoint &univ2screen) const;

#define CMK_LIVEVIZ3D_INTERESTVIEWRENDER 0 /* need to be pup::able to render... */
#if CMK_LIVEVIZ3D_INTERESTVIEWRENDER
    virtual void render(double alpha);
#endif
};



class CkInterestViewable : public CkViewable {
    CkInterestSet interest; 
    CkVector3d center; 
    CkVector3d boundCenter; double boundRadius;
protected:
    void setUnivPoints(const CkInterestSet &univPoints_);
    void setCenter(const CkVector3d &center_) {center=center_;}
public:
    CkInterestViewable() {}
    
    virtual bool shouldRender(const CkViewpoint &univ2screen,const CkView &oldView);
    
    virtual CkView *renderView(const CkViewpoint &univ2screen);
    
    virtual bool newViewpoint(const CkViewpoint &univ2screen,CkViewpoint &univ2texture);
    
    virtual void renderImage(const CkViewpoint &vp,CkImage &dest) =0;
    
    virtual double getSize(const CkViewpoint &univ2screen);
};

#endif /*def(thisHeader)*/

---