source: branches/BinPackingExtension/HeuristicLab.Problems.BinPacking/3.3/3D/PermutationEncoding/ExtremePointPermutationDecoderBase.cs @ 14976

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.BinPacking3D {
  [Item("Extreme-point Permutation Decoder (3d) Base", "Base class for decoders")]
  [StorableClass]
  public abstract class ExtremePointPermutationDecoderBase : Item, IDecoder<Permutation> {

    [StorableConstructor]
    protected ExtremePointPermutationDecoderBase(bool deserializing) : base(deserializing) { }
    protected ExtremePointPermutationDecoderBase(ExtremePointPermutationDecoderBase original, Cloner cloner)
      : base(original, cloner) {
    }
    public ExtremePointPermutationDecoderBase() : base() { }

    public abstract Solution Decode(Permutation permutation, PackingShape binShape, IList<PackingItem> items, bool useStackingConstraints);

    public virtual bool FindExtremePointForItem(Dictionary<Tuple<BinPacking3D, PackingPosition>, int> PointsSpace, PackingItem item, bool rotated, bool stackingConstraints, out BinPacking3D bin, out PackingPosition pos) {

      PackingItem newItem = new PackingItem(
        rotated ? item.Depth : item.Width,
        item.Height,
        rotated ? item.Width : item.Depth,
        item.TargetBin, item.Weight, item.Material);

      var EPoints = PointsSpace.Keys.ToList();
      BinPacking3D bp;
      PackingPosition position;
      int epIndex = 0;
      while (epIndex < EPoints.Count && (
        !(((bp = EPoints.ElementAt(epIndex).Item1)).IsPositionFeasible(newItem, (position = EPoints.ElementAt(epIndex).Item2)))
        || !bp.IsSupportedByAtLeastOnePoint(newItem, position)
        || (stackingConstraints && !bp.IsStaticStable(newItem, position))
        || (stackingConstraints && !bp.IsWeightSupported(newItem, position))
      )) { epIndex++; }

      if (epIndex < EPoints.Count) {
        bin = EPoints.ElementAt(epIndex).Item1;
        var origPoint = EPoints.ElementAt(epIndex).Item2;
        pos = new PackingPosition(origPoint.AssignedBin, origPoint.X, origPoint.Y, origPoint.Z, rotated);

        return true;
      }
      bin = null;
      pos = null;
      return false;
    }

    public virtual Dictionary<Tuple<BinPacking3D, PackingPosition>, int> GetResidualSpaceAllPoints(Solution solution, PackingItem item) {
      Dictionary<Tuple<BinPacking3D, PackingPosition>, int> result = new Dictionary<Tuple<BinPacking3D, PackingPosition>, int>();
      foreach (BinPacking3D bp in solution.Bins) {
        foreach (var ep in bp.ExtremePoints) {
          result.Add(Tuple.Create(bp, ep), bp.GetResidualSpace(item, ep));
        }
      }
      return result;
    }

    public virtual bool ExtremePointBasedPacking(Dictionary<Tuple<BinPacking3D, PackingPosition>, int> PointsSpace, int itemID, IList<PackingItem> items, bool stackingConstraints) {
      BinPacking3D bp;
      PackingPosition positionFound;
      var item = items[itemID];
      if (FindExtremePointForItem(PointsSpace, item, false, stackingConstraints, out bp, out positionFound)) {
        bp.PackItem(itemID, item, positionFound);
        return true;
      }
      return false;
    }
  }
}