Changeset 14045


Ignore:
Timestamp:
07/12/16 18:23:13 (9 months ago)
Author:
gkronber
Message:

#1966: removed types for *PackingBin because PackingBins and PackingShapes have the same capabilities

Location:
branches/HeuristicLab.BinPacking
Files:
49 edited
3 moved

Legend:

Unmodified
Added
Removed
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs

    r14040 r14045  
    2828using HeuristicLab.Common;
    2929using HeuristicLab.Problems.BinPacking.Dimensions;
    30 using HeuristicLab.Problems.BinPacking.PackingBin;
     30
     31using HeuristicLab.Problems.BinPacking.Shapes;
    3132
    3233namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
    3334  [Item("BinPacking2D", "Represents a single-bin packing for a 2D bin-packing problem.")]
    3435  [StorableClass]
    35   public class BinPacking2D : BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
    36 
    37     public BinPacking2D(RectangularPackingBin binMeasures)
     36  public class BinPacking2D : BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> {
     37
     38    public BinPacking2D(RectangularPackingShape binMeasures)
    3839      : base(binMeasures) {
    3940      ExtremePoints = new SortedSet<TwoDimensionalPacking>(new EPComparer2D());
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftGroupingVectorDecoder.cs

    r13607 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3131using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    3232using HeuristicLab.Problems.BinPacking2D;
     33using HeuristicLab.Problems.BinPacking.Shapes;
    3334
    3435namespace HeuristicLab.Problems.BinPacking.Decoders {
    3536  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
    3637  [StorableClass]
    37   public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin,RectangularPackingItem>, I2DGVDecoder {
     38  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
    3839    public BottomLeftGroupingVectorDecoder() : base() {}
    3940    [StorableConstructor]
     
    4647    }
    4748
    48     public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     49    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    4950      var solution = encodedSolution as GroupingVectorEncoding;
    5051      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs

    r13606 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
    2726using HeuristicLab.Problems.BinPacking.PackingItem;
    2827using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3130using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
    3231using HeuristicLab.Problems.BinPacking2D;
     32using HeuristicLab.Problems.BinPacking.Shapes;
    3333
    3434namespace HeuristicLab.Problems.BinPacking.Decoders {
    3535  [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
    3636  [StorableClass]
    37   public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking,RectangularPackingBin, RectangularPackingItem>, I2DMCVDecoder {
     37  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking,RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
    3838    public BottomLeftMultiComponentVectorDecoder() : base() {}
    3939    [StorableConstructor]
     
    4646    }
    4747
    48     public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     48    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    4949      var solution = encodedSolution as MultiComponentVectorEncoding;
    5050      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs

    r13607 r14045  
    2525using HeuristicLab.Core;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
     27
    2828using HeuristicLab.Problems.BinPacking.PackingItem;
    2929using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3232using HeuristicLab.Problems.BinPacking.Interfaces;
    3333using HeuristicLab.Problems.BinPacking2D;
     34using HeuristicLab.Problems.BinPacking.Shapes;
    3435
    3536namespace HeuristicLab.Problems.BinPacking.Decoders {
    3637  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
    3738  [StorableClass]
    38   public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, I2DPSDecoder {
     39  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
    3940
    4041    public BottomLeftPackingSequenceDecoder(): base() { }
     
    4849    }
    4950
    50     public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     51    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    5152      var solution = encodedSolution as PackingSequenceEncoding;
    5253      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs

    r13607 r14045  
    2525using HeuristicLab.Core;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
     27
    2828using HeuristicLab.Problems.BinPacking.PackingItem;
    2929using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3232using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    3333using HeuristicLab.Problems.BinPacking2D;
     34using HeuristicLab.Problems.BinPacking.Shapes;
    3435
    3536namespace HeuristicLab.Problems.BinPacking.Decoders {
    3637  [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
    3738  [StorableClass]
    38   public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, I2DGVDecoder {
     39  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
    3940    public ExtremePointGroupingVectorDecoder2D () : base() {}
    4041    [StorableConstructor]
     
    4748    }
    4849
    49     public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     50    public static PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    5051      PackingPlan2D result = new PackingPlan2D(binMeasures, true, false);
    5152      result.Pack(solution, itemMeasures);
     
    5354    }
    5455
    55     public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     56    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    5657      var solution = encodedSolution as GroupingVectorEncoding;
    5758      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs

    r13607 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3131using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
    3232using HeuristicLab.Problems.BinPacking2D;
     33using HeuristicLab.Problems.BinPacking.Shapes;
    3334
    3435namespace HeuristicLab.Problems.BinPacking.Decoders {
    3536  [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] // TODO
    3637  [StorableClass]
    37   public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking,RectangularPackingBin, RectangularPackingItem>, I2DMCVDecoder {
     38  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
    3839    public ExtremePointMultiComponentVectorDecoder2D () : base() {}
    3940    [StorableConstructor]
     
    4647    }
    4748
    48     public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     49    public static PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    4950      PackingPlan2D result = new PackingPlan2D(binMeasures, true, false);
    5051      result.Pack(solution, itemMeasures);
     
    5253    }
    5354
    54     public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     55    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    5556      var solution = encodedSolution as MultiComponentVectorEncoding;
    5657      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs

    r13607 r14045  
    2525using HeuristicLab.Core;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
    2827using HeuristicLab.Problems.BinPacking.PackingItem;
    2928using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3231using HeuristicLab.Problems.BinPacking.Interfaces;
    3332using HeuristicLab.Problems.BinPacking2D;
     33using HeuristicLab.Problems.BinPacking.Shapes;
    3434
    3535namespace HeuristicLab.Problems.BinPacking.Decoders {
    3636  [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] // TODO
    3737  [StorableClass]
    38   public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, I2DPSDecoder {
     38  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
    3939    public ExtremePointPackingSequenceDecoder2D () : base() {}
    4040    [StorableConstructor]
     
    4848
    4949
    50     public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
     50    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    5151      var solution = encodedSolution as PackingSequenceEncoding;
    5252      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj

    r13611 r14045  
    177177    <Compile Include="Properties\AssemblyInfo.cs" />
    178178    <Compile Include="RectangularIdenticalBinPackingProblem.cs" />
    179     <Compile Include="RectangularPackingBin.cs" />
    180179    <Compile Include="RectangularPackingItem.cs" />
    181180    <Compile Include="RectangularPackingShape.cs" />
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs

    r13607 r14045  
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    2727using HeuristicLab.Problems.BinPacking.Interfaces;
    28 using HeuristicLab.Problems.BinPacking.PackingBin;
     28
    2929using HeuristicLab.Problems.BinPacking.PackingItem;
     30using HeuristicLab.Problems.BinPacking.Shapes;
    3031using HeuristicLab.Problems.BinPacking2D.Interfaces;
    3132
     
    3334  [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
    3435  [StorableClass]
    35   public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
     36  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
    3637    [StorableConstructor]
    3738    protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs

    r13607 r14045  
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    2727using HeuristicLab.Problems.BinPacking.Interfaces;
    28 using HeuristicLab.Problems.BinPacking.PackingBin;
     28
    2929using HeuristicLab.Problems.BinPacking.PackingItem;
     30using HeuristicLab.Problems.BinPacking.Shapes;
    3031using HeuristicLab.Problems.BinPacking2D.Interfaces;
    3132
     
    3334  [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
    3435  [StorableClass]
    35   public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
     36  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
    3637    [StorableConstructor]
    3738    protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs

    r13607 r14045  
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    2727using HeuristicLab.Problems.BinPacking.Interfaces;
    28 using HeuristicLab.Problems.BinPacking.PackingBin;
     28
    2929using HeuristicLab.Problems.BinPacking.PackingItem;
     30using HeuristicLab.Problems.BinPacking.Shapes;
    3031using HeuristicLab.Problems.BinPacking2D.Interfaces;
    3132
     
    3334  [Item("PackingSequenceMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
    3435  [StorableClass]
    35   public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
     36  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
    3637    [StorableConstructor]
    3738    protected PackingMoveEvaluator2DPS(bool deserializing) : base(deserializing) { }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPlan2D.cs

    r13611 r14045  
    2525using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
     27
    2828using HeuristicLab.Problems.BinPacking.PackingItem;
     29using HeuristicLab.Problems.BinPacking.Shapes;
    2930
    3031namespace HeuristicLab.Problems.BinPacking2D {
    3132  [Item("PackingPlan2D", "Represents a solution for a 2D bin packing problem.")]
    3233  [StorableClass]
    33   public class PackingPlan2D : PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
    34     public PackingPlan2D(RectangularPackingBin binMeasures) : this(binMeasures, false, false) { }
    35     public PackingPlan2D(RectangularPackingBin binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
     34  public class PackingPlan2D : PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> {
     35    public PackingPlan2D(RectangularPackingShape binMeasures) : this(binMeasures, false, false) { }
     36    public PackingPlan2D(RectangularPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
    3637    [StorableConstructor]
    3738    protected PackingPlan2D(bool deserializing) : base(deserializing) { }
     
    4243      return new PackingPlan2D(this, cloner);
    4344    }
    44     public override BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> NewBinPacking() {
     45    public override BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> NewBinPacking() {
    4546      return new Encodings.PackingEncoding.PackingPlan.BinPacking2D(BinMeasures);
    4647    }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs

    r13606 r14045  
    2525using HeuristicLab.Common;
    2626using HeuristicLab.Problems.BinPacking.PackingItem;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
    2827using HeuristicLab.Problems.BinPacking.Dimensions;
     28using HeuristicLab.Problems.BinPacking.Shapes;
    2929
    3030namespace HeuristicLab.Problems.BinPacking.Evaluators {
    3131  [Item("Packing-Ratio Rectangular Identical-Bin Evaluator", "Represents an evaluation-algorithm for rectangular-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
    3232  [StorableClass]
    33   public class PackingRatioRectangularIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
     33  public class PackingRatioRectangularIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> {
    3434
    3535    [StorableConstructor]
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs

    r14040 r14045  
    2222using HeuristicLab.Problems.BinPacking.Dimensions;
    2323using HeuristicLab.Problems.BinPacking.Interfaces;
    24 using HeuristicLab.Problems.BinPacking.PackingBin;
     24
    2525using HeuristicLab.Problems.BinPacking.PackingItem;
    2626using HeuristicLab.Core;
     
    3636using HeuristicLab.Data;
    3737using System;
     38using HeuristicLab.Problems.BinPacking.Shapes;
    3839
    3940namespace HeuristicLab.Problems.BinPacking.Problem {
     
    4243  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
    4344  // TODO: only support 2d BPPData
    44   public class RectangularIdenticalBinPackingProblem : BinPackingProblem<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
     45  public class RectangularIdenticalBinPackingProblem : BinPackingProblem<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
    4546
    4647    #region Default Instance
     
    101102    }
    102103    public RectangularIdenticalBinPackingProblem() : base(
    103       new PackingPlanEvaluationAlgorithm<Permutation, TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>()) {
     104      new PackingPlanEvaluationAlgorithm<Permutation, TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>()) {
    104105    }
    105106
     
    107108    public void Load(BPPData data) {
    108109      var realData = data as RealBPPData;
    109       var binData = new RectangularPackingBin(data.BinMeasures[0], data.BinMeasures[1]);
     110      var binData = new RectangularPackingShape(data.BinMeasures[0], data.BinMeasures[1]);
    110111
    111112      var itemData = new ItemList<RectangularPackingItem>(data.Items);
    112113      for (int j = 0; j < data.Items; j++) {
    113         var bin = new RectangularPackingBin(data.BinMeasures[0], data.BinMeasures[1]);
     114        var bin = new RectangularPackingShape(data.BinMeasures[0], data.BinMeasures[1]);
    114115        var item = new RectangularPackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], bin);
    115116        if (realData != null) {
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingItem.cs

    r14039 r14045  
    2828using HeuristicLab.Data;
    2929using HeuristicLab.Parameters;
    30 using HeuristicLab.Problems.BinPacking.PackingBin;
     30
    3131
    3232namespace HeuristicLab.Problems.BinPacking.PackingItem {
     
    3535  public class RectangularPackingItem : RectangularPackingShape, IPackingItem {
    3636
    37     public RectangularPackingBin TargetBin {
    38       get { return ((IValueParameter<RectangularPackingBin>)Parameters["TargetBin"]).Value; }
    39       set { ((IValueParameter<RectangularPackingBin>)Parameters["TargetBin"]).Value = value; }
     37    public RectangularPackingShape TargetBin {
     38      get { return ((IValueParameter<RectangularPackingShape>)Parameters["TargetBin"]).Value; }
     39      set { ((IValueParameter<RectangularPackingShape>)Parameters["TargetBin"]).Value = value; }
    4040    }
    4141
     
    6262    public RectangularPackingItem()
    6363      : base() {
    64       Parameters.Add(new ValueParameter<RectangularPackingBin>("TargetBin"));
     64      Parameters.Add(new ValueParameter<RectangularPackingShape>("TargetBin"));
    6565      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
    6666      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
    6767    }
    6868
    69     public RectangularPackingItem(int width, int height, RectangularPackingBin targetBin)
     69    public RectangularPackingItem(int width, int height, RectangularPackingShape targetBin)
    7070      : this() {
    7171      this.Width = width;
    7272      this.Height = height;
    73       this.TargetBin = (RectangularPackingBin)targetBin.Clone();
     73      this.TargetBin = (RectangularPackingShape)targetBin.Clone();
    7474    }
    7575
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs

    r14043 r14045  
    3333  [Item("RectangularPackingShape", "Represents the rectangular measures (width, height) of a two-dimensional bin-packing object.")]
    3434  [StorableClass]
    35   public abstract class RectangularPackingShape : PackingShape<TwoDimensionalPacking>, IComparable<RectangularPackingShape> {
     35  public class RectangularPackingShape : PackingShape<TwoDimensionalPacking>, IComparable<RectangularPackingShape> {
    3636    public int Height {
    3737      get { return ((IFixedValueParameter<IntValue>)Parameters["Height"]).Value.Value; }
     
    4949      : base(original, cloner) {
    5050    }
    51     protected RectangularPackingShape()
     51    public RectangularPackingShape()
    5252      : base() {
    5353      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
    5454      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
    5555    }
    56     protected RectangularPackingShape(int width, int height)
     56    public RectangularPackingShape(int width, int height)
    5757      : this() {
    5858      this.Height = height;
    5959      this.Width = width;
     60    }
     61
     62    public override IDeepCloneable Clone(Cloner cloner) {
     63      return new RectangularPackingShape(this, cloner);
    6064    }
    6165
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs

    r14038 r14045  
    2727using HeuristicLab.Common;
    2828using HeuristicLab.Problems.BinPacking.Dimensions;
    29 using HeuristicLab.Problems.BinPacking.PackingBin;
     29using HeuristicLab.Problems.BinPacking.Shapes;
    3030
    3131namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
    3232  [Item("BinPacking3D", "Represents a single-bin packing for a 3D bin-packing problem.")]
    3333  [StorableClass]
    34   public class BinPacking3D : BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
    35 
    36     public BinPacking3D(CuboidPackingBin binMeasures)
     34  public class BinPacking3D : BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> {
     35
     36    public BinPacking3D(CuboidPackingShape binMeasures)
    3737      : base(binMeasures) {
    3838      ExtremePoints = new SortedSet<ThreeDimensionalPacking>(new EPComparer3D());
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs

    r14040 r14045  
    2222using HeuristicLab.Problems.BinPacking.Dimensions;
    2323using HeuristicLab.Problems.BinPacking.Interfaces;
    24 using HeuristicLab.Problems.BinPacking.PackingBin;
     24
    2525using HeuristicLab.Problems.BinPacking.PackingItem;
    2626using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     
    3636using System;
    3737using HeuristicLab.Data;
     38using HeuristicLab.Problems.BinPacking.Shapes;
    3839
    3940namespace HeuristicLab.Problems.BinPacking.Problem {
     
    4243  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
    4344  // TODO don't support generic BPPData but only 3d BPPData
    44   public class CuboidIdenticalBinPackingProblem : BinPackingProblem<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
     45  public class CuboidIdenticalBinPackingProblem : BinPackingProblem<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
    4546
    4647
     
    106107    }
    107108    public CuboidIdenticalBinPackingProblem() : base(
    108       new PackingPlanEvaluationAlgorithm<Permutation, ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>()) {
     109      new PackingPlanEvaluationAlgorithm<Permutation, ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>()) {
    109110    }
    110111
     
    113114    public void Load(BPPData data) {
    114115      var realData = data as RealBPPData;
    115       var binData = new CuboidPackingBin(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
     116      var binData = new CuboidPackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
    116117
    117118      var itemData = new ItemList<CuboidPackingItem>(data.Items);
    118119      for (int j = 0; j < data.Items; j++) {
    119         var bin = new CuboidPackingBin(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
     120        var bin = new CuboidPackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
    120121        var item = new CuboidPackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], data.ItemMeasures[j][2], bin);
    121122        if (realData != null) {
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingItem.cs

    r13608 r14045  
    2828using HeuristicLab.Data;
    2929using HeuristicLab.Parameters;
    30 using HeuristicLab.Problems.BinPacking.PackingBin;
     30
    3131
    3232namespace HeuristicLab.Problems.BinPacking.PackingItem {
     
    3434  [StorableClass]
    3535  public class CuboidPackingItem : CuboidPackingShape, IPackingItem {
    36     public IValueParameter<CuboidPackingBin> TargetBinParameter {
    37       get { return (IValueParameter<CuboidPackingBin>)Parameters["TargetBin"]; }
     36    public IValueParameter<CuboidPackingShape> TargetBinParameter {
     37      get { return (IValueParameter<CuboidPackingShape>)Parameters["TargetBin"]; }
    3838    }
    3939    public IFixedValueParameter<DoubleValue> WeightParameter {
     
    4444    }
    4545
    46     public CuboidPackingBin TargetBin {
     46    public CuboidPackingShape TargetBin {
    4747      get { return TargetBinParameter.Value; }
    4848      set { TargetBinParameter.Value = value; }
     
    7171    public CuboidPackingItem()
    7272      : base() {
    73       Parameters.Add(new ValueParameter<CuboidPackingBin>("TargetBin"));
     73      Parameters.Add(new ValueParameter<CuboidPackingShape>("TargetBin"));
    7474      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
    7575      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
     
    7878    }
    7979
    80     public CuboidPackingItem(int width, int height, int depth, CuboidPackingBin targetBin, double weight, int material)
     80    public CuboidPackingItem(int width, int height, int depth, CuboidPackingShape targetBin, double weight, int material)
    8181      : this() {
    8282      this.Width = width;
     
    8585      this.Weight = weight;
    8686      this.Material = material;
    87       this.TargetBin = (CuboidPackingBin)targetBin.Clone();
     87      this.TargetBin = (CuboidPackingShape)targetBin.Clone();
    8888    }
    8989
    90     public CuboidPackingItem(int width, int height, int depth, CuboidPackingBin targetBin)
     90    public CuboidPackingItem(int width, int height, int depth, CuboidPackingShape targetBin)
    9191      : this() {
    9292      this.Width = width;
    9393      this.Height = height;
    9494      this.Depth = depth;
    95       this.TargetBin = (CuboidPackingBin)targetBin.Clone();
     95      this.TargetBin = (CuboidPackingShape)targetBin.Clone();
    9696    }
    9797
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs

    r14043 r14045  
    3232  [Item("CuboidPackingShape", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
    3333  [StorableClass]
    34   public abstract class CuboidPackingShape : PackingShape<ThreeDimensionalPacking>, IComparable<CuboidPackingShape> {
     34  public class CuboidPackingShape : PackingShape<ThreeDimensionalPacking>, IComparable<CuboidPackingShape> {
    3535    public IFixedValueParameter<IntValue> HeightParameter {
    3636      get { return (IFixedValueParameter<IntValue>)Parameters["Height"]; }
     
    6464      RegisterEvents();
    6565    }
    66     protected CuboidPackingShape()
     66    public CuboidPackingShape()
    6767      : base() {
    6868      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
     
    7373    }
    7474
    75     protected CuboidPackingShape(int width, int height, int depth)
     75    public CuboidPackingShape(int width, int height, int depth)
    7676      : this() {
    7777      this.Width = width;
    7878      this.Height = height;
    7979      this.Depth = depth;
     80    }
     81
     82    public override IDeepCloneable Clone(Cloner cloner) {
     83      return new CuboidPackingShape(this, cloner);
    8084    }
    8185
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs

    r13032 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3030using HeuristicLab.Problems.BinPacking.Interfaces;
    3131using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
     32using HeuristicLab.Problems.BinPacking.Shapes;
    3233
    3334namespace HeuristicLab.Problems.BinPacking.Decoders {
    3435  [Item("Identical bin, three dimensional, GroupingVector-decoder", "<Description missing...>")]
    3536  [StorableClass]
    36   public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, I3DGVDecoder {
     37  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
    3738    public DeepestBottomLeftGroupingVectorDecoder() : base() {}
    3839    [StorableConstructor]
     
    4546    }
    4647
    47     public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     48    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    4849      var solution = encodedSolution as GroupingVectorEncoding;
    4950      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs

    r13032 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3030using HeuristicLab.Problems.BinPacking.Interfaces;
    3131using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     32using HeuristicLab.Problems.BinPacking.Shapes;
    3233
    3334namespace HeuristicLab.Problems.BinPacking.Decoders {
    3435  [Item("Identical bin, three dimensional, MultiComponentVector-decoder", "<Description missing...>")]
    3536  [StorableClass]
    36   public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, I3DMCVDecoder {
     37  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
    3738    public DeepestBottomLeftMultiComponentVectorDecoder() : base() { }
    3839    [StorableConstructor]
     
    4546    }
    4647
    47     public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     48    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    4849      var solution = encodedSolution as MultiComponentVectorEncoding;
    4950      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs

    r13032 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3030using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    3131using HeuristicLab.Problems.BinPacking.Interfaces;
     32using HeuristicLab.Problems.BinPacking.Shapes;
    3233
    3334namespace HeuristicLab.Problems.BinPacking.Decoders {
    3435  [Item("Identical bin, three dimensional, PackingSequence-decoder", "<Description missing...>")]
    3536  [StorableClass]
    36   public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, I3DPSDecoder {
     37  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
    3738    public DeepestBottomLeftPackingSequenceDecoder(): base() {}
    3839    [StorableConstructor]
     
    4546    }
    4647
    47     public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     48    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    4849      var solution = encodedSolution as PackingSequenceEncoding;
    4950      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs

    r13032 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3030using HeuristicLab.Problems.BinPacking.Interfaces;
    3131using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
     32using HeuristicLab.Problems.BinPacking.Shapes;
    3233
    3334namespace HeuristicLab.Problems.BinPacking.Decoders {
    3435  [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
    3536  [StorableClass]
    36   public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, I3DGVDecoder {
     37  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
    3738    public ExtremePointGroupingVectorDecoder3D() : base() { }
    3839    [StorableConstructor]
     
    4546    }
    4647
    47     public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
     48    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
    4849      PackingPlan3D result = new PackingPlan3D(binMeasures, true, stackingConstraints);
    4950      result.Pack(solution, itemMeasures);
     
    5152    }
    5253
    53     public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     54    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    5455      var solution = encodedSolution as GroupingVectorEncoding;
    5556      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs

    r13032 r14045  
    2424using HeuristicLab.Core;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
    2828using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3030using HeuristicLab.Problems.BinPacking.Interfaces;
    3131using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     32using HeuristicLab.Problems.BinPacking.Shapes;
    3233
    3334namespace HeuristicLab.Problems.BinPacking.Decoders {
    3435  [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
    3536  [StorableClass]
    36   public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, I3DMCVDecoder {
     37  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
    3738    public ExtremePointMultiComponentVectorDecoder3D () : base() { }
    3839    [StorableConstructor]
     
    4546    }
    4647
    47     public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
     48    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
    4849      PackingPlan3D result = new PackingPlan3D(binMeasures, true, stackingConstraints);
    4950      result.Pack(solution, itemMeasures);
     
    5152    }
    5253
    53     public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     54    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    5455      var solution = encodedSolution as MultiComponentVectorEncoding;
    5556      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs

    r13032 r14045  
    2525using HeuristicLab.Core;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
     27
    2828using HeuristicLab.Problems.BinPacking.PackingItem;
    2929using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
     
    3131using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    3232using HeuristicLab.Problems.BinPacking.Interfaces;
     33using HeuristicLab.Problems.BinPacking.Shapes;
    3334
    3435namespace HeuristicLab.Problems.BinPacking.Decoders {
    3536  [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
    3637  [StorableClass]
    37   public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, I3DPSDecoder {
     38  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
    3839    public ExtremePointPackingSequenceDecoder3D () : base() {}
    3940    [StorableConstructor]
     
    4748
    4849
    49     public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     50    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    5051      var solution = encodedSolution as PackingSequenceEncoding;
    5152      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj

    r14040 r14045  
    160160    <Compile Include="BinPacking3D.cs" />
    161161    <Compile Include="CuboidIdenticalBinPackingProblem.cs" />
    162     <Compile Include="CuboidPackingBin.cs" />
    163162    <Compile Include="CuboidPackingItem.cs" />
    164163    <Compile Include="CuboidPackingShape.cs" />
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs

    r13608 r14045  
    2727using HeuristicLab.Problems.BinPacking.Dimensions;
    2828using HeuristicLab.Problems.BinPacking.Interfaces;
    29 using HeuristicLab.Problems.BinPacking.PackingBin;
     29
    3030using HeuristicLab.Problems.BinPacking.PackingItem;
     31using HeuristicLab.Problems.BinPacking.Shapes;
    3132
    3233namespace HeuristicLab.Problems.BinPacking {
    3334  [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
    3435  [StorableClass]
    35   public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
     36  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
    3637    [StorableConstructor]
    3738    protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs

    r13608 r14045  
    2727using HeuristicLab.Problems.BinPacking.Dimensions;
    2828using HeuristicLab.Problems.BinPacking.Interfaces;
    29 using HeuristicLab.Problems.BinPacking.PackingBin;
     29
    3030using HeuristicLab.Problems.BinPacking.PackingItem;
     31using HeuristicLab.Problems.BinPacking.Shapes;
    3132
    3233namespace HeuristicLab.Problems.BinPacking {
    3334  [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
    3435  [StorableClass]
    35   public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
     36  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
    3637    [StorableConstructor]
    3738    protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs

    r13608 r14045  
    2727using HeuristicLab.Problems.BinPacking.Dimensions;
    2828using HeuristicLab.Problems.BinPacking.Interfaces;
    29 using HeuristicLab.Problems.BinPacking.PackingBin;
     29
    3030using HeuristicLab.Problems.BinPacking.PackingItem;
     31using HeuristicLab.Problems.BinPacking.Shapes;
    3132
    3233namespace HeuristicLab.Problems.BinPacking {
    3334  [Item("PackingSequenceMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
    3435  [StorableClass]
    35   public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
     36  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
    3637    [StorableConstructor]
    3738    protected PackingMoveEvaluator3DPS(bool deserializing) : base(deserializing) { }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingPlan3D.cs

    r13611 r14045  
    44using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    55using HeuristicLab.Problems.BinPacking.Dimensions;
    6 using HeuristicLab.Problems.BinPacking.PackingBin;
     6
    77using HeuristicLab.Problems.BinPacking.PackingItem;
     8using HeuristicLab.Problems.BinPacking.Shapes;
    89
    910namespace HeuristicLab.Problems.BinPacking {
    1011  [Item("PackingPlan3D", "Represents a solution for a 3D bin packing problem.")]
    1112  [StorableClass]
    12   public class PackingPlan3D : PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
    13     public PackingPlan3D(CuboidPackingBin binMeasures) : this(binMeasures, false, false) { }
    14     public PackingPlan3D(CuboidPackingBin binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
     13  public class PackingPlan3D : PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> {
     14    public PackingPlan3D(CuboidPackingShape binMeasures) : this(binMeasures, false, false) { }
     15    public PackingPlan3D(CuboidPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
    1516    [StorableConstructor]
    1617    protected PackingPlan3D(bool deserializing) : base(deserializing) { }
     
    2122      return new PackingPlan3D(this, cloner);
    2223    }
    23     public override BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> NewBinPacking() {
     24    public override BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> NewBinPacking() {
    2425      return new BinPacking3D(BinMeasures);
    2526    }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs

    r13608 r14045  
    2424using HeuristicLab.Common;
    2525using HeuristicLab.Problems.BinPacking.Dimensions;
    26 using HeuristicLab.Problems.BinPacking.PackingBin;
     26
    2727using HeuristicLab.Problems.BinPacking.PackingItem;
     28using HeuristicLab.Problems.BinPacking.Shapes;
    2829
    2930namespace HeuristicLab.Problems.BinPacking.Evaluators {
    3031  [Item("Packing-Ratio Cuboid Identical-Bin Evaluator", "Represents an evaluation-algorithm for cuboid-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
    3132  [StorableClass]
    32   public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
     33  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> {
    3334
    3435    [StorableConstructor]
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs

    r13605 r14045  
    2525using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
    2827using HeuristicLab.Problems.BinPacking.PackingItem;
     28using HeuristicLab.Problems.BinPacking.Shapes;
    2929using Point = System.Windows.Point;
    3030using Size = System.Windows.Size;
     
    3535    private int selectedItemKey;
    3636    private Size renderSize;
    37     private BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> packing;
    38     public BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Packing {
     37    private BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> packing;
     38    public BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Packing {
    3939      get { return packing; }
    4040      set {
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs

    r13605 r14045  
    2626using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    2727using HeuristicLab.Problems.BinPacking.Dimensions;
    28 using HeuristicLab.Problems.BinPacking.PackingBin;
    2928using HeuristicLab.Problems.BinPacking.PackingItem;
     29using HeuristicLab.Problems.BinPacking.Shapes;
    3030
    3131namespace HeuristicLab.Problems.BinPacking.Views {
     
    3737    private int selectedItemKey;
    3838
    39     private BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> packing;
    40     public BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Packing {
     39    private BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> packing;
     40    public BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Packing {
    4141      get { return packing; }
    4242      set {
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs

    r14038 r14045  
    2525using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    2626using HeuristicLab.Problems.BinPacking.Dimensions;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
     27
    2828using HeuristicLab.Problems.BinPacking.PackingItem;
     29using HeuristicLab.Problems.BinPacking.Shapes;
    2930
    3031namespace HeuristicLab.Problems.BinPacking.Views {
    3132  [View("2-dimensional packing plan view")]
    32   [Content(typeof(PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>), true)]
     33  [Content(typeof(PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>), true)]
    3334  public partial class PackingPlan2DView : ItemView {
    3435
     
    3738    }
    3839
    39     public new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Content {
    40       get { return (PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>)base.Content; }
     40    public new PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Content {
     41      get { return (PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>)base.Content; }
    4142      set { base.Content = value; }
    4243    }
     
    5859    }
    5960
    60     private void UpdateState(PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> plan) {
     61    private void UpdateState(PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> plan) {
    6162      int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0;
    6263      container2DView.Packing = plan.BinPackings[currentBin];
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs

    r13576 r14045  
    2525using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    2626using HeuristicLab.Problems.BinPacking.PackingItem;
    27 using HeuristicLab.Problems.BinPacking.PackingBin;
     27
    2828using HeuristicLab.Problems.BinPacking.Dimensions;
     29using HeuristicLab.Problems.BinPacking.Shapes;
    2930
    3031namespace HeuristicLab.Problems.BinPacking.Views {
    3132  [View("3-dimensional packing plan View")]
    32   [Content(typeof(PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>), true)]
     33  [Content(typeof(PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>), true)]
    3334  public partial class PackingPlan3DView : ItemView {
    3435
     
    3738    }
    3839
    39     public new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Content {
    40       get { return (PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>)base.Content; }
     40    public new PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Content {
     41      get { return (PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>)base.Content; }
    4142      set { base.Content = value; }
    4243    }
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs

    r14043 r14045  
    3838  public class BestBinPackingSolutionAnalyzer<D, B, I> : BinPackingAnalyzer<D, B, I>, IStochasticOperator
    3939    where D : class, IPackingDimensions
    40     where B : PackingShape<D>, IPackingBin
     40    where B : PackingShape<D>
    4141    where I : PackingShape<D>, IPackingItem {
    4242
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs

    r13605 r14045  
    3636  public abstract class BinPackingAnalyzer<D, B, I> : SingleSuccessorOperator, IAnalyzer
    3737    where D : class, IPackingDimensions
    38     where B : PackingShape<D>, IPackingBin
     38    where B : PackingShape<D>
    3939    where I : PackingShape<D>, IPackingItem {
    4040    public virtual bool EnabledByDefault {
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs

    r14043 r14045  
    4343  public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator>
    4444    where D : class, IPackingDimensions
    45     where B : PackingShape<D>, IPackingBin, new()
     45    where B : PackingShape<D>, new()
    4646    where I : PackingShape<D>, IPackingItem, new () {
    4747
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs

    r13605 r14045  
    3434  public abstract class BinPacking<D,B,I>  : Item
    3535    where D : class, IPackingDimensions
    36     where B : PackingShape<D>, IPackingBin
     36    where B : PackingShape<D>
    3737    where I : PackingShape<D>, IPackingItem {
    3838    #region Properties
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs

    r13611 r14045  
    4040  public abstract class PackingPlan<D, B, I> :Item, IPackingPlan
    4141    where D : class, IPackingDimensions
    42     where B : PackingShape<D>, IPackingBin
     42    where B : PackingShape<D>
    4343    where I : PackingShape<D>, IPackingItem {
    4444
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs

    r14043 r14045  
    3434  public abstract class BinUtilizationRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
    3535    where D : class, IPackingDimensions
    36     where B : PackingShape<D>, IPackingBin
     36    where B : PackingShape<D>
    3737    where I : PackingShape<D>, IPackingItem {
    3838
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs

    r13608 r14045  
    3636    where E : Item //E defines the used Encoding
    3737    where D : class, IPackingDimensions
    38     where B : PackingShape<D>, IPackingBin
     38    where B : PackingShape<D>
    3939    where I : PackingShape<D>, IPackingItem {
    4040
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs

    r13608 r14045  
    3535  public abstract class PackingPlanEvaluator<D,B,I> : SingleSuccessorOperator, IPackingPlanEvaluator
    3636    where D : class, IPackingDimensions
    37     where B : PackingShape<D>, IPackingBin
     37    where B : PackingShape<D>
    3838    where I : PackingShape<D>, IPackingItem {
    3939
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs

    r14043 r14045  
    3434  public abstract class PackingRatioRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
    3535    where D : class, IPackingDimensions
    36     where B : PackingShape<D>, IPackingBin
     36    where B : PackingShape<D>
    3737    where I : PackingShape<D>, IPackingItem {
    3838
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs

    r14043 r14045  
    3333  public abstract class RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I> : PackingPlanEvaluator<D, B, I>
    3434    where D : class, IPackingDimensions
    35     where B : PackingShape<D>, IPackingBin
     35    where B : PackingShape<D>
    3636    where I : PackingShape<D>, IPackingItem {
    3737
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj

    r14043 r14045  
    282282    <Compile Include="PackingDimensions.cs" />
    283283    <Compile Include="PackingMoveEvaluator.cs" />
    284     <Compile Include="Interfaces\IPackingBin.cs" />
    285284    <Compile Include="Interfaces\IPackingItem.cs" />
    286285    <Compile Include="Interfaces\IPackingPlan.cs" />
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs

    r14043 r14045  
    3838  public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
    3939    where D : class, IPackingDimensions
    40     where B : PackingShape<D>, IPackingBin
     40    where B : PackingShape<D>
    4141    where I : PackingShape<D>, IPackingItem {     
    4242    public override bool CanChangeName {
  • branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs

    r13613 r14045  
    3737  public abstract class PackingSolutionDecoder<D, B, I> : SingleSuccessorOperator, IPackingSolutionDecoder
    3838    where D : class, IPackingDimensions
    39     where B : PackingShape<D>, IPackingBin
     39    where B : PackingShape<D>
    4040    where I : PackingShape<D>, IPackingItem {
    4141
Note: See TracChangeset for help on using the changeset viewer.