public void Parse(Stream stream) { var reader = new StreamReader(stream); var length = GetNextInteger(reader); var width = GetNextInteger(reader); var height = GetNextInteger(reader); var maxWeight = GetNextInteger(reader); Bin = new PackingShape(width, height, length); Items = new List <PackingItem>(); while (true) { try { var id = GetNextInteger(reader); var pieces = GetNextInteger(reader); length = GetNextInteger(reader); width = GetNextInteger(reader); height = GetNextInteger(reader); var weight = GetNextInteger(reader); var stack = GetNextInteger(reader); var material = GetNextInteger(reader); var rotate = GetNextInteger(reader); var tilt = GetNextInteger(reader); for (var i = 0; i < pieces; i++) { Items.Add(new PackingItem(width, height, length, Bin, weight, material)); } } catch (InvalidOperationException) { break; } } }
public PackingItem(int width, int height, int depth, PackingShape targetBin) : this() { this.Width = width; this.Height = height; this.Depth = depth; this.TargetBin = (PackingShape)targetBin.Clone(); }
public override double EvaluateMove(Permutation permutation, Swap2Move move, PackingShape binShape, ReadOnlyItemList <PackingItem> items, bool useStackingConstraints) { // uses full evaluation Swap2Manipulator.Apply(permutation, move.Index1, move.Index2); var solution = DecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints); return(SolutionEvaluatorParameter.ActualValue.Evaluate(solution)); }
public CuboidDiagonal(PackingPosition myPosition, PackingShape myShape) { x1 = myPosition.X; y1 = myPosition.Y; z1 = myPosition.Z; x2 = myPosition.X + (myPosition.Rotated ? myShape.Depth : myShape.Width) - 1; y2 = myPosition.Y + myShape.Height - 1; z2 = myPosition.Z + (myPosition.Rotated ? myShape.Width : myShape.Depth) - 1; }
public override Solution Decode(IntegerVector intVec, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints) { // TODO if (useStackingConstraints) { throw new NotSupportedException("Stacking constraints are not supported by the Bottom-Left IntegerVector Decoder"); } return(base.Decode(intVec, binShape, items, useStackingConstraints: false)); }
public PackingItem(int width, int height, int depth, PackingShape targetBin, double weight, int material) : this() { this.Width = width; this.Height = height; this.Depth = depth; this.Weight = weight; this.Material = material; this.TargetBin = (PackingShape)targetBin.Clone(); }
public virtual Solution Decode(IntegerVector intVec, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints) { var sequenceMatrix = IntegerVectorProblem.GenerateSequenceMatrix(intVec); Solution result = CreateSolution(binShape, useStackingConstraints); //Fill bins according to grouping vector IList <int> remainingIDs = new List <int>(); foreach (var sequence in sequenceMatrix) { remainingIDs = remainingIDs.Concat(sequence).ToList(); result.Bins.Add(CreatePacking(result, ref remainingIDs, items, useStackingConstraints)); } result.UpdateBinPackings(); //Try to put remaining items in existing bins var temp = new List <int>(remainingIDs); foreach (int id in temp) { foreach (BinPacking3D bp in result.Bins) { var position = FindPositionForItem(bp, items[id], useStackingConstraints); if (position != null) { bp.PackItem(id, items[id], position); remainingIDs.Remove(id); break; } } } //Put still remaining items in new bins while (remainingIDs.Count > 0) { result.Bins.Add(CreatePacking(result, ref remainingIDs, items, useStackingConstraints)); } result.UpdateBinPackings(); // gkronber: original implementation by Helm also updates the encoded solution (TODO) // var newSolution = new int[intVec.Length]; // int binIndex = 0; // foreach (var bp in result.BinPackings) { // foreach (var entry in bp.ItemPositions) // newSolution[entry.Key] = binIndex; // binIndex++; // } // solution.GroupingVector = new IntegerVector(newSolution); return(result); }
public Solution Decode(Permutation permutation, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints) { Solution result = new Solution(binShape, useExtremePoints: true, stackingConstraints: useStackingConstraints); IList <int> remainingIDs = new List <int>(permutation); while (remainingIDs.Count > 0) { var bp = new BinPacking3D(binShape); bp.ExtremePointBasedPacking(ref remainingIDs, items, stackingConstraints: useStackingConstraints); result.Bins.Add(bp); } result.UpdateBinPackings(); return(result); }
public int CompareTo(PackingShape other) { //Using "Clustered-Area-Height"-comparison as descr int result = (this.Width * this.Depth).CompareTo(other.Width * other.Depth); if (result == 0) { result = this.Volume.CompareTo(other.Volume); } if (result == 0) { result = this.Height.CompareTo(other.Height); } return(result); }
public static Solution Apply(Permutation permutation, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints) { Solution result = new Solution(binShape, useExtremePoints: true, stackingConstraints: useStackingConstraints); IList <int> remainingIDs = new List <int>(permutation); var bpg = new BinPacking3D(binShape); bpg.ExtremePointBasedPacking(ref remainingIDs, items, stackingConstraints: useStackingConstraints); result.Bins.Add(bpg); foreach (int ID in remainingIDs) { var item = items[ID]; var points = GetResidualSpaceAllPoints(result, item); var sortedPoints = points.OrderBy(x => x.Item3); var packed = false; foreach (var p in sortedPoints) { packed = p.Item1.PackItemIfFeasible(ID, item, p.Item2, useStackingConstraints); if (packed) { break; } } if (!packed) { // pack item in a new bin var bp = new BinPacking3D(binShape); var positionFound = bp.FindExtremePointForItem(item, false, useStackingConstraints); if (positionFound != null) { bp.PackItem(ID, item, positionFound); } else { throw new InvalidOperationException("Item " + ID + " cannot be packed in an empty bin."); } result.Bins.Add(bp); } } result.UpdateBinPackings(); return(result); }
public static Solution Apply(Permutation permutation, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints) { Solution result = new Solution(binShape, useExtremePoints: true, stackingConstraints: useStackingConstraints); IList <int> remainingIDs = new List <int>(permutation); var bpg = new BinPacking3D(binShape); bpg.ExtremePointBasedPacking(ref remainingIDs, items, stackingConstraints: useStackingConstraints); result.Bins.Add(bpg); foreach (int ID in remainingIDs) { var sortedBins = result.Bins.OrderBy(x => x.FreeVolume); var item = items[ID]; var posFound = false; foreach (var bp in sortedBins) { var pos = bp.FindExtremePointForItem(item, false, useStackingConstraints); posFound = pos != null; if (posFound) { bp.PackItem(ID, item, pos); break; } } if (!posFound) { var bp = new BinPacking3D(binShape); var pos = bp.FindExtremePointForItem(item, false, useStackingConstraints); if (pos == null) { throw new InvalidOperationException("Item " + ID + " cannot be packed in empty bin."); } bp.PackItem(ID, item, pos); result.Bins.Add(bp); } } result.UpdateBinPackings(); return(result); }
private Tuple <Solution, double, SortingMethod?, FittingMethod?> GetBest(PackingShape bin, IList <PackingItem> items, SortingMethod[] sortings, FittingMethod[] fittings, CancellationToken token) { SortingMethod?bestSorting = null; FittingMethod?bestFitting = null; var best = double.NaN; Solution bestSolution = null; foreach (var fit in fittings) { foreach (var sort in sortings) { var result = Optimize(bin, items, sort, fit, DeltaParameter.Value.Value, Problem.UseStackingConstraints, Problem.SolutionEvaluator, token); if (double.IsNaN(result.Item2) || double.IsInfinity(result.Item2)) { continue; } if (double.IsNaN(best) || Problem.Maximization && result.Item2 > best || !Problem.Maximization && result.Item2 < best) { bestSolution = result.Item1; best = result.Item2; bestSorting = sort; bestFitting = fit; } if (token.IsCancellationRequested) { return(Tuple.Create(bestSolution, best, bestSorting, bestFitting)); } } } if (double.IsNaN(best)) { return(null); } return(Tuple.Create(bestSolution, best, bestSorting, bestFitting)); }
private bool Encloses(PackingPosition checkedPosition, PackingShape checkedShape) { return(Encloses(new CuboidDiagonal(this), new CuboidDiagonal(checkedPosition, checkedShape))); }
public abstract double EvaluateMove(TSol encodedSolutionCandidate, TMove move, PackingShape binShape, ReadOnlyItemList <PackingItem> items, bool useStackingConstraints);
private static Tuple <Solution, double> Optimize(PackingShape bin, IList <PackingItem> items, SortingMethod sorting, FittingMethod fitting, double delta, bool stackingConstraints, IEvaluator evaluator, CancellationToken token) { Permutation sorted = null; switch (sorting) { case SortingMethod.Given: sorted = new Permutation(PermutationTypes.Absolute, Enumerable.Range(0, items.Count).ToArray()); break; case SortingMethod.VolumeHeight: sorted = new Permutation(PermutationTypes.Absolute, items.Select((v, i) => new { Index = i, Item = v }) .OrderByDescending(x => x.Item.Depth * x.Item.Width * x.Item.Height) .ThenByDescending(x => x.Item.Height) .Select(x => x.Index).ToArray()); break; case SortingMethod.HeightVolume: sorted = new Permutation(PermutationTypes.Absolute, items.Select((v, i) => new { Index = i, Item = v }) .OrderByDescending(x => x.Item.Height) .ThenByDescending(x => x.Item.Depth * x.Item.Width * x.Item.Height) .Select(x => x.Index).ToArray()); break; case SortingMethod.AreaHeight: sorted = new Permutation(PermutationTypes.Absolute, items.Select((v, i) => new { Index = i, Item = v }) .OrderByDescending(x => x.Item.Depth * x.Item.Width) .ThenByDescending(x => x.Item.Height) .Select(x => x.Index).ToArray()); break; case SortingMethod.HeightArea: sorted = new Permutation(PermutationTypes.Absolute, items.Select((v, i) => new { Index = i, Item = v }) .OrderByDescending(x => x.Item.Height) .ThenByDescending(x => x.Item.Depth * x.Item.Width) .Select(x => x.Index).ToArray()); break; case SortingMethod.ClusteredAreaHeight: double clusterRange = bin.Width * bin.Depth * delta; sorted = new Permutation(PermutationTypes.Absolute, items.Select((v, i) => new { Index = i, Item = v, ClusterId = (int)(Math.Ceiling(v.Width * v.Depth / clusterRange)) }) .GroupBy(x => x.ClusterId) .Select(x => new { Cluster = x.Key, Items = x.OrderByDescending(y => y.Item.Height).ToList() }) .OrderByDescending(x => x.Cluster) .SelectMany(x => x.Items) .Select(x => x.Index).ToArray()); break; case SortingMethod.ClusteredHeightArea: double clusterRange2 = bin.Height * delta; sorted = new Permutation(PermutationTypes.Absolute, items.Select((v, i) => new { Index = i, Item = v, ClusterId = (int)(Math.Ceiling(v.Height / clusterRange2)) }) .GroupBy(x => x.ClusterId) .Select(x => new { Cluster = x.Key, Items = x.OrderByDescending(y => y.Item.Depth * y.Item.Width).ToList() }) .OrderByDescending(x => x.Cluster) .SelectMany(x => x.Items) .Select(x => x.Index).ToArray()); break; default: throw new ArgumentException("Unknown sorting method: " + sorting); } ExtremePointPermutationDecoderBase decoder = null; switch (fitting) { case FittingMethod.FirstFit: decoder = new ExtremePointPermutationDecoder(); break; case FittingMethod.FreeVolumeBestFit: decoder = new FreeVolumeBestFitExtremePointPermutationDecoder(); break; case FittingMethod.ResidualSpaceBestFit: decoder = new ResidualSpaceBestFitExtremePointPermutationDecoder(); break; default: throw new ArgumentException("Unknown fitting method: " + fitting); } var sol = decoder.Decode(sorted, bin, items, stackingConstraints); var fit = evaluator.Evaluate(sol); return(Tuple.Create(sol, fit)); }
protected abstract Solution CreateSolution(PackingShape binShape, bool useStackingConstraints);
public override Solution Decode(Permutation permutation, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints) { return(Apply(permutation, binShape, items, useStackingConstraints)); }
public CuboidDiagonal(PackingShape myShape) : this(new PackingPosition(0, 0, 0, 0), myShape) { }
protected PackingShape(PackingShape original, Cloner cloner) : base(original, cloner) { RegisterEvents(); }
private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape checkedShape) { return(Overlaps(new CuboidDiagonal(myPosition, this), new CuboidDiagonal(checkedPosition, checkedShape))); }
public abstract Solution Decode(Permutation permutation, PackingShape binShape, IList <PackingItem> items, bool useStackingConstraints);
public override bool Encloses(PackingPosition checkedPosition, PackingShape <PackingPosition> checkedShape) { return(Encloses(checkedPosition, (PackingShape)checkedShape)); }
protected override Solution CreateSolution(PackingShape binShape, bool useStackingConstraints) { return(new Solution(binShape, useExtremePoints: true, stackingConstraints: useStackingConstraints)); }
public override bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape <PackingPosition> checkedShape) { return(Overlaps(myPosition, checkedPosition, (PackingShape)checkedShape)); }