source: branches/HeuristicLab.BinPacking/PackingPlanVisualizations/2D/CenteredContainer2D.cs @ 13032

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

using System.Collections.Generic;
using SharpDX;


namespace PackingPlanVisualizations {
  public class CenteredContainer2D {
    private Vector2 containerSize;
    private Vector2 controlSize;
    private float normalizingFactor;

    public Vector2 ContainerCenter { 
      get { return new Vector2(controlSize.X / 2, controlSize.Y / 2); } 
    }

    private struct PackingItem {
      private Vector2 position;
      private Vector2 size;
      private string label;
      public PackingItem(Vector2 size, Vector2 position, string label, CenteredContainer2D parentContainer) {
        this.size = size;
        this.position = position;
        this.label = label;
      }
      public RectangleF GetRectangle(Vector2 topLeft, float normalizingFactor) {
        return new RectangleF(
          topLeft.X  + position.X * normalizingFactor + 2,
          topLeft.Y  + position.Y * normalizingFactor + 2,
          topLeft.X  + position.X * normalizingFactor + size.X * normalizingFactor - 2,
          topLeft.Y  + position.Y * normalizingFactor + size.Y * normalizingFactor - 2
        );
      }
      public string GetLabel() {
        return label;
      }
    }
    private List<PackingItem> packingItems = new List<PackingItem>();

    //public struct LabelStructure {
    //  private string text;
    //  public string Text { get { return text; } }
    //  private RectangleF layoutRect;
    //  public RectangleF LayoutRectangle { get { return layoutRect; } }
    //  public LabelStructure(string text, RectangleF layout) {
    //    this.text = text;
    //    this.layoutRect = layout;
    //  }
    //}
        
    public CenteredContainer2D (Vector2 controlSize, Vector2 containerSize) {
      this.containerSize = containerSize;
      UpdateContainer(controlSize);
    }
    public CenteredContainer2D(float controlWidth, float controlHeight, float containerWidth, float containerHeight) 
      : this(new Vector2 (controlWidth, controlHeight), new Vector2(containerWidth, containerHeight)) { 
    }

    public void AddItem(Vector2 size, Vector2 position, string label) {
      packingItems.Add(new PackingItem (size, position, label, this));
    }
    public void AddItem(float width, float height, float x, float y, string label) {
      AddItem(new Vector2 (width, height), new Vector2 (x, y), label);
    }
     
    public void UpdateContainer(Vector2 controlSize) {
      this.controlSize = controlSize;
      if (controlSize.X / controlSize.Y > containerSize.X / containerSize.Y)
        this.normalizingFactor = controlSize.Y / (containerSize.Y + 5);
      else if (controlSize.X / controlSize.Y <= containerSize.X / containerSize.Y)
        this.normalizingFactor = controlSize.X / (containerSize.X + 5);
    }
    public void UpdateContainer(float controlWidth, float controlHeight) {
      UpdateContainer(new Vector2 (controlWidth, controlHeight));
    }


    public RectangleF GetContainerData() {
      //Compute centered rectangle
      SharpDX.RectangleF result = new SharpDX.RectangleF(
        ContainerCenter.X - containerSize.X * normalizingFactor / 2 - 2,
        ContainerCenter.Y - containerSize.Y * normalizingFactor / 2 - 2,
        ContainerCenter.X + containerSize.X * normalizingFactor / 2 + 2,
        ContainerCenter.Y + containerSize.Y * normalizingFactor / 2 + 2);

      return result;
    }

    public struct LabeledRectangle {
      public string label;
      public RectangleF rectangle;

      public LabeledRectangle(string label, RectangleF rectangle) {
        this.label = label;
        this.rectangle = rectangle;
      }
    }
    public List<LabeledRectangle> GetItemRectangles() {
      List<LabeledRectangle> result = new List<LabeledRectangle> ();

      foreach (PackingItem item in packingItems) {
        result.Add(new LabeledRectangle(item.GetLabel(), item.GetRectangle(new Vector2(
          ContainerCenter.X - containerSize.X * normalizingFactor / 2,
          ContainerCenter.Y - containerSize.Y * normalizingFactor / 2), normalizingFactor)));
      }

      return result;
    }
  }
}