instance_builder.hpp

#pragma once

#include "packingsolver/box/instance.hpp"

namespace packingsolver
{
namespace box
{

class InstanceBuilder
{

public:

    /** Constructor. */
    InstanceBuilder() { }

    /** Set the objective. */
    void set_objective(Objective objective) { instance_.objective_ = objective; }

    /*
     * Read from files
     */

    /** Read parameters from a file. */
    void read_parameters(const std::string& parameters_path);

    /** Read bin types from a file. */
    void read_bin_types(const std::string& bins_path);

    /** Read item types from a file. */
    void read_item_types(const std::string& items_path);

    /*
     * Set parameters
     */

    /** Set parameters. */
    void set_parameters(const Parameters& parameters) { instance_.parameters_ = parameters; }

    /*
     * Set bin types
     */

    /** Add a bin type. */
    BinTypeId add_bin_type(
            Length x,
            Length y,
            Length z,
            Profit cost = -1,
            BinPos copies = 1,
            BinPos copies_min = 0);

    /** Set the maximum weight of a bin type. */
    void set_bin_type_maximum_weight(
            BinTypeId bin_type_id,
            Weight maximum_weight);

    /**
     * Add a bin type from another bin type.
     *
     * This method is used in the column generation procedure.
     */
    void add_bin_type(
            const Instance& original_instance,
            BinTypeId original_bin_type_id,
            BinPos copies,
            BinPos copies_min = 0);

    /**
     * For each bin type, set an infinite x.
     *
     * This method is used to transform a problem into a Strip Packing problem.
     */
    void set_bin_types_infinite_x();

    /**
     * For each bin type, set an infinite y.
     *
     * This method is used to transform a problem into a Strip Packing problem.
     */
    void set_bin_types_infinite_y();

    /**
     * Foe each bin type, set an infinite number of copies.
     *
     * This method should be used after reading bin files of Bin Packing
     * Problems where the number of bin types is not given. By default, the
     * number of bins would be set to 1.
     */
    void set_bin_types_infinite_copies();

    /**
     * For each bin type, set its cost to its volume.
     *
     * This method is used to transform a Variable-sized Bin Packing Problem
     * into an Unweighted Variable-sized Bin Packing Problem.
     */
    void set_bin_types_unweighted();

    /*
     * Set item types
     */

    /** Add an item type. */
    ItemTypeId add_item_type(
            Length x,
            Length y,
            Length z,
            Profit p = -1,
            ItemPos copies = 1,
            int rotations = 1);

    /** Set the weight of an item type. */
    void set_item_type_weight(
            ItemTypeId item_type_id,
            Weight weight);

    /**
     * Add an item type from another item type.
     *
     * This method is used in the column generation procedure.
     */
    void add_item_type(
            const Instance& original_instance,
            ItemTypeId original_item_type_id,
            Profit profit,
            ItemPos copies);

    /** Set a default value for the item type profits. */
    void set_item_types_profits_auto();

    /**
     * For each item type, set an infinite number of copies.
     *
     * This method is used to transform a Knapsack Problem into an Unbounded
     * Knapsack Problem.
     */
    void set_item_types_infinite_copies();

    /**
     * For each item type, set its profit to its volume.
     *
     * This method is used to transform a Knapsack Problem into an Unweighted
     * Knapsack Problem.
     */
    void set_item_types_unweighted();

    /** For each item type, set 'oriented' to 'true'. */
    void set_item_types_oriented();

    /*
     * Build
     */

    /** Build. */
    Instance build();

private:

    /*
     * Private methods
     */

    /** Compute item type max length sum. */
    Length compute_item_types_max_length_sum() const;

    /** Compute bin attributes. */
    void compute_bin_attributes();

    /** Compute bin types volume max. */
    Area compute_bin_types_volume_max() const;

    /*
     * Private attributes
     */

    /** Instance. */
    Instance instance_;

    /** Mapping from original bin type IDs to sub-instance bin type IDs. */
    std::vector<BinTypeId> orig_to_sub_bin_type_ids_;

    /** Mapping from original item type IDs to sub-instance item type IDs. */
    std::vector<ItemTypeId> orig_to_sub_item_type_ids_;

};

}
}