Hiding Templates

• Templates are useful to avoid multiple implementations
  (eg RD_Image<T>)
• Problem: Any classes using such classes may have to be
  templated themselves
• Too many templates: Slow compilation and `code bloat'
• We can hide templating using abstract base classes
• For instance TC_ImageBase is parent to TC_Image<T>:

class TC_ImageBase
{
public:
    virtual ~TC_ImageBase() {};
    const TC_Transform2D& world2im() const;

    virtual int xlo() const =0;
    virtual int xhi() const =0;
    virtual int ylo() const =0;
    virtual int yhi() const =0;
};

template<class T>
class TC_Image : public TC_ImageBase
{
public:
...
    RD_Image<T>& image(); 
}

class TC_ImageToVectorBase {
public:
    ...
    virtual void sample(RD_Vector& v, 
                        const TC_ImageBase& image, 
                        const RD_Array<RD_GmPoint>& pts) =0;
    // Warp image using pts and sample into v
};

• Derived classes cast image to appropriate templated class
• Clients need not worry about details of image type, as long as the derived implementations of ImageToVectorBase match the actual image type.

For instance:

class TC_RegionModel {
public:
    TC_RegionModel(const TC_ImageToVectorBase&, 
                   const TC_VectorModelBase&,
                   const TC_VTransformBase& normaliser);

    // Find b which best fit model to image given pts:
    void params(RD_Vector& b, RD_Vector& g_trans,
                const TC_ImageBase& image, 
                const RD_Array<RD_GmPoint>& pts);

    // Reconstruct image given b and pts:
    void reconstruct(TC_ImageBase& image,
                     const RD_Vector& b, const RD_Vector& g_trans,
                     const RD_Array<RD_GmPoint>& pts);
    ...
};