RobotSceneConfiguration.h

/*
 * Copyright (c) 2018, Stefan Osswald
 * 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 copyright holder 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 INCLUDE_ARTICULATION_ROBOTSCENECONFIGURATION_H_
#define INCLUDE_ARTICULATION_ROBOTSCENECONFIGURATION_H_

#include <gpu_coverage/AbstractRenderer.h>
#include <gpu_coverage/Node.h>
#include <glm/detail/type_mat4x4.hpp>
#include <stdexcept>
#include <list>

namespace gpu_coverage {

class RobotSceneConfiguration {
public:
    RobotSceneConfiguration();
    explicit RobotSceneConfiguration(const RobotSceneConfiguration& other);
    virtual ~RobotSceneConfiguration();

    float getCost(RobotSceneConfiguration& previousConfig) const;

    float getGain(RobotSceneConfiguration& previousConfig) const;

    inline float getEvaluation(RobotSceneConfiguration& previousConfig) const {
        return getGain(previousConfig) - getCost(previousConfig);
    }

    void set(const RobotSceneConfiguration& other) {
        cameraLocalTransform = other.cameraLocalTransform;
        cameraPosition = other.cameraPosition;
        // numArticulation is the same for all instances, hence the
        // array does not need to be reallocated or resized.
        memcpy(articulation, other.articulation, numArticulation * sizeof(float));
        count = other.count;
    }

    void setRandomArticulation(unsigned int& seed);

    void setRandomCameraHeight(unsigned int& seed);

    void setRandomCameraPosition(unsigned int& seed, const std::vector<glm::vec3> * const targetPoints);

    void setCameraHeight(const float& value);

    void setCameraLocalTransform(const glm::mat4x4& cameraTransform);

    inline const glm::mat4x4& getCameraLocalTransform() const {
        return cameraLocalTransform;
    }

    void applyToScene(Scene * const scene) const;

    inline float getArticulation(const size_t& handle) const {
#ifdef DEBUG
        if (handle >= numArticulation) {
            throw std::out_of_range("RobotSceneConfiguration::getArticulation index out of range");
        }
#endif
        return articulation[handle];
    }

    inline void setArticulation(const size_t& handle, const float& value) {
#ifdef DEBUG
        if (handle >= numArticulation) {
            throw std::out_of_range("RobotSceneConfiguration::setArticulation index out of range");
        }
#endif
        articulation[handle] = value;
    }

    inline const GLuint& getCount() const {
        return count;
    }

    inline void setCount(const GLuint& count) {
        this->count = count;
    }

    static void loadCosts();

    static size_t numArticulation;   

protected:
    glm::mat4x4 cameraLocalTransform;          
    glm::vec3 cameraPosition;                  
    float *articulation;                       
    GLuint count;                              

    struct ArticulationCost {
        float constant;   
        float linear;     

        ArticulationCost(const float& constant = 0.0f, const float& linear = 0.0f)
                : constant(constant), linear(linear) {
        }
    };

    static float costCameraHeightChange;        
    static float costDistance;                  
    static float minCameraHeight;               
    static float maxCameraHeight;               
    static float gainFactor;                    
    static ArticulationCost *costArticulation;  

    friend class RandomSearchTask;
    friend class HillclimbingTask;

};

} /* namespace gpu_coverage */

#endif /* INCLUDE_ARTICULATION_ROBOTSCENECONFIGURATION_H_ */