Representer.h

/*
 * This file is part of the statismo library.
 *
 * Author: Marcel Luethi (marcel.luethi@unibas.ch)
 *
 * Copyright (c) 2011 University of Basel
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * Neither the name of the project's author nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#ifndef REPRESENTER_H_
#define REPRESENTER_H_

#include <string>
#include <H5Cpp.h>

#include "CommonTypes.h"
#include "Domain.h"

//RB: would it be possible to make all representers inherit from it, so as to strictly enforce the interface?
namespace statismo {

template<class T>
class RepresenterTraits {
};

template<class T>
class Representer {

  public:

    enum RepresenterDataType {
        UNKNOWN = 0,
        POINT_SET = 1,
        POLYGON_MESH = 2,
        VOLUME_MESH = 3,
        IMAGE = 4,
        VECTOR = 5,
        CUSTOM = 99
    };

    static RepresenterDataType TypeFromString(const std::string& s) {
        if (s == "POINT_SET")
            return POINT_SET;
        else if (s == "POLYGON_MESH")
            return POLYGON_MESH;
        else if (s == "VOLUME_MESH")
            return VOLUME_MESH;
        else if (s == "IMAGE")
            return IMAGE;
        else if (s == "VECTOR")
            return VECTOR;
        else if (s == "CUSTOM")
            return CUSTOM;
        else
            return UNKNOWN;
    }

    static std::string TypeToString(const RepresenterDataType& type) {
        switch (type) {
        case POINT_SET: {
            return "POINT_SET";
            break;
        }
        case POLYGON_MESH: {
            return "POLYGON_MESH";
            break;
        }
        case VOLUME_MESH: {
            return "VOLUME_MESH";
            break;
        }
        case IMAGE: {
            return "IMAGE";
            break;
        }
        case VECTOR: {
            return "VECTOR";
            break;
        }
        case CUSTOM: {
            return "CUSTOM";
            break;
        }
        default: {
            return "UNKNOWN";
        }
        }
    }

    typedef typename RepresenterTraits<T>::DatasetPointerType DatasetPointerType;

    typedef typename RepresenterTraits<T>::DatasetConstPointerType DatasetConstPointerType;

    typedef typename RepresenterTraits<T>::PointType PointType;

    typedef typename RepresenterTraits<T>::ValueType ValueType;

    typedef T DatasetType;

    typedef Domain<PointType> DomainType;

    virtual ~Representer() {
    }

    virtual std::string GetName() const = 0;

    virtual RepresenterDataType GetType() const = 0;

    virtual unsigned GetDimensions() const = 0;

    virtual std::string GetVersion() const = 0;


    virtual void Load(const H5::Group& fg) = 0;

    virtual Representer* Clone() const = 0;

    virtual void Delete() const = 0;


    virtual void DeleteDataset(DatasetPointerType d) const = 0;
    virtual DatasetPointerType CloneDataset(DatasetConstPointerType d) const = 0;






    virtual const statismo::Domain<PointType>& GetDomain() const = 0;


    virtual DatasetConstPointerType GetReference() const = 0;

    virtual VectorType PointToVector(const PointType& pt) const = 0;

    virtual VectorType SampleToSampleVector(
        DatasetConstPointerType sample) const = 0;

    virtual DatasetPointerType SampleVectorToSample(
        const VectorType& sample) const = 0;

    virtual ValueType PointSampleFromSample(DatasetConstPointerType sample,
                                            unsigned ptid) const = 0;

    virtual ValueType PointSampleVectorToPointSample(
        const VectorType& v) const = 0;

    virtual VectorType PointSampleToPointSampleVector(
        const ValueType& pointSample) const = 0;

    virtual unsigned MapPointIdToInternalIdx(unsigned ptId,
            unsigned componentInd) const {
        return ptId * GetDimensions() + componentInd;
    }

    virtual unsigned GetPointIdForPoint(const PointType& point) const = 0;



    virtual void Save(const H5::Group& fg) const = 0;

};

}

#endif /* REPRESENTER_H_ */