Changeset 14040

Timestamp:

07/12/16 17:51:37 (8 years ago)

Author:

gkronber

Message:

#1966:

• removed separation of general bin packing problems and 'regular' (=rectangular or cuboid) bin packing problems (=> all our bin packing problems are regular)
• removed ISOContainer BinPacking problem (seems to be just a minor variant for generic 3d bin packing)

Location:

branches/HeuristicLab.BinPacking

Files:

• HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs (modified) (1 diff)
• HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs (modified) (3 diffs)
• HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs (modified) (3 diffs)
• HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs (modified) (6 diffs)
• HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs (modified) (1 diff)

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs

@@ -66 +66 @@
         ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y));
       }
-
-
-
 
       //Find ExtremePoints beginning from sourcepointY

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs

@@ -41 +41 @@
   [StorableClass]
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
-  public class RectangularIdenticalBinPackingProblem : RegularIdenticalBinPackingProblem<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
+  // TODO: only support 2d BPPData
+  public class RectangularIdenticalBinPackingProblem : BinPackingProblem<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
 
     #region Default Instance
@@ -104 +105 @@
 
     #region Problem instance handling
-    public override void Load(BPPData data) {
+    public void Load(BPPData data) {
       var realData = data as RealBPPData;
       var binData = new RectangularPackingBin(data.BinMeasures[0], data.BinMeasures[1]);
@@ -131 +132 @@
 
 
-    public override BPPData Export() {
+    public BPPData Export() {
       var result = new BPPData {
         Name = Name,

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs

@@ -41 +41 @@
   [StorableClass]
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
-  public class CuboidIdenticalBinPackingProblem : RegularIdenticalBinPackingProblem<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
+  // TODO don't support generic BPPData but only 3d BPPData
+  public class CuboidIdenticalBinPackingProblem : BinPackingProblem<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+
 
     #region Default Instance
@@ -109 +111 @@
 
 
-    public override void Load(BPPData data) {
+    public void Load(BPPData data) {
       var realData = data as RealBPPData;
       var binData = new CuboidPackingBin(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
@@ -135 +137 @@
     }
 
-    public override BPPData Export() {
+    public BPPData Export() {
       var result = new BPPData {
         Name = Name,

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj

@@ -172 +172 @@
     <Compile Include="Decoders\EP\ExtremePointMultiComponentVectorDecoder3D.cs" />
     <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder3D.cs" />
-    <Compile Include="Decoders\EP\ISOContainerMultiComponentVectorDecoder3D.cs" />
     <Compile Include="I3DOperator.cs" />
-    <Compile Include="ISOContainerBinPackingProblem.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DGV.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs" />

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs

@@ -29 +29 @@
 using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.PluginInfrastructure;
+using System.Linq;
+using HeuristicLab.Problems.BinPacking.Analyzers;
+using System;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -35 +43 @@
   public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
     where D : class, IPackingDimensions 
-    where B : PackingShape<D>, IPackingBin, new()
-    where I : PackingShape<D>, IPackingItem, new () {
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape, new()
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape, new () {
 
 
@@ -54 +62 @@
     public ValueParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
       get { return (ValueParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    public IValueParameter<B> PackingBinMeasuresParameter {
+      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
     }
     #endregion
@@ -70 +84 @@
       set { PackingPlanEvaluatorParameter.Value = value; }
     }
+    public B PackingBinMeasures {
+      get { return PackingBinMeasuresParameter.Value; }
+      set { PackingBinMeasuresParameter.Value = value; }
+    }
+    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
+      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
+      set { PackingSolutionDecoderParameter.Value = value; }
+    }
     #endregion
 
@@ -77 +99 @@
     protected BinPackingProblem(BinPackingProblem<D,B,I> original, Cloner cloner)
       : base(original, cloner) {
-    }                 
+      InitializeEventHandlers();
+    }
+
+    protected BinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
+
     protected BinPackingProblem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c) : base (e, c){
       Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
@@ -84 +110 @@
       Parameters.Add(new FixedValueParameter<IntValue>("PackingItems", "The number of packing-items used in this bin packing instance.", new IntValue()));
       Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)", new IntValue()));
-    }
-
-    protected abstract void InitializeDecoder(); 
-    protected abstract void InitializeProblemInstance();
-    protected abstract void InitializeOperators();
-    protected abstract void InitializeEventHandlers();
+      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
+      Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
+      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
+      this.Maximization.Value = true;
+      InitializeProblemInstance();
+      InitializeOperators();
+      InitializeEventHandlers();
+    }
+
+    protected abstract void InitializeDecoder();
+    protected virtual void InitializeProblemInstance() {
+      InitializeProblemData();
+      ApplyHorizontalOrientation();
+      SortItems();
+      RemoveTooBigItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+    protected virtual void InitializeOperators() {
+      Operators.Clear();
+      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
+
+      ApplyEncoding();
+      ParameterizeOperators();
+    }
+    protected virtual void InitializeEventHandlers() {
+      PackingPlanEvaluatorParameter.ValueChanged += PackingPlanEvaluatorParameter_ValueChanged;
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      SolutionCreatorParameter.ValueChanged += SolutionCreatorParameter_ValueChanged;
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      PackingSolutionDecoderParameter.ValueChanged += PackingSolutionDecoderParameter_ValueChanged;
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+    }
+
+
+    protected abstract void RemoveTooBigItems();
+    protected abstract void InitializeProblemData();
+    protected abstract IPackingPlanEvaluator CreateDefaultEvaluator();
+    protected void ApplyHorizontalOrientation() {
+      PackingBinMeasures.ApplyHorizontalOrientation();
+      foreach (IRegularPackingShape shape in PackingItemMeasures) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+    protected void SortItems() {
+      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
+    }
+    protected int CalculateLowerBound() {
+      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
+      int items = PackingItemMeasures.Select(x => x.Volume).Sum();
+      int bin = PackingBinMeasures.Volume;
+      return (items + bin - 1) / (bin);
+    }
+
+    private void ApplyEncoding() {
+      if (SolutionCreator.GetType() == typeof(PackingSequenceRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
+        InitializeDecoder();
+      }
+    }
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      }
+
+      Evaluator.PackingSolutionDecoderParameter.ActualName = PackingSolutionDecoderParameter.Name;
+      Evaluator.PackingSolutionDecoderParameter.Hidden = true;
+      Evaluator.PackingPlanEvaluatorParameter.ActualName = PackingPlanEvaluatorParameter.Name;
+      Evaluator.PackingPlanEvaluatorParameter.Hidden = true;
+      Evaluator.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      Evaluator.QualityParameter.Hidden = true;
+
+      if (PackingSolutionDecoder != null)
+        PackingSolutionDecoder.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+
+      if (PackingSolutionDecoder != null) {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = true;
+      } else {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingPlanEvaluator.PackingPlanParameter.Name;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
+        op.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.EncodedSolutionParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionCrossover>()) {
+        op.ChildParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ChildParameter.Hidden = true;
+        op.ParentsParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ParentsParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+        if (PackingSolutionDecoder != null) {
+          op.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+          op.PackingPlanParameter.Hidden = true;
+        } else {
+          op.PackingPlanParameter.ActualName = op.PackingPlanParameter.Name;
+          op.PackingPlanParameter.Hidden = false;
+        }
+      }
+
+    }
+
+    #region Events
+    protected override void OnSolutionCreatorChanged() {
+      InitializeOperators();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void SolutionCreator_EncodedSolutionParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    #endregion
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj

@@ -290 +290 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RegularIdenticalBinPackingProblem.cs" />
   </ItemGroup>
   <ItemGroup>

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs

@@ -47 +47 @@
 
     #region Parameter Properties
-    public IValueParameter<B> PackingBinMeasuresParameter {
-      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
+
     #endregion
 
     #region Properties
-    public B PackingBinMeasures {
-      get { return PackingBinMeasuresParameter.Value; }
-      set { PackingBinMeasuresParameter.Value = value; }
-    }
-    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
-      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
-      set { PackingSolutionDecoderParameter.Value = value; }
-    }
+
     #endregion