rectangle_array.h

#pragma once
 
 
#include "rectangle.h"
 
 
template < prototype_number NUMBER >
class rectangle_array_base :
public ::array_base < ::rectangle_type < NUMBER > >
{
public:
 
   using BASE_ARRAY = ::array_base < ::rectangle_type < NUMBER > >;
   //using RECTANGLE_BASE_TYPE = ::rectangle_type < NUMBER >;
   //using UNIT_TYPE = typename ::rectangle_type < NUMBER >::UNIT_TYPE;
   using UNIT_TYPE = NUMBER;
   //using POINT_TYPE = typename ::rectangle_type < NUMBER >::POINT_TYPE;
   //using SIZE_TYPE = typename ::rectangle_type < NUMBER >::SIZE_TYPE;
 
   
   using BASE_ARRAY::BASE_ARRAY;
   using BASE_ARRAY::operator =;
   //rectangle_array_base(const rectangle_array_base & a) noexcept : array < ::rectangle_type < NUMBER > > (a) { }
   //rectangle_array_base(rectangle_array_base && a) noexcept : array < ::rectangle_type < NUMBER > >(::transfer(a)) { }
 
   
   //~rectangle_array_base();
 
   using array_base < ::rectangle_type < NUMBER > >::add;
   void add(const ::rectangle_type < NUMBER > & rectangle);
   void add(UNIT_TYPE left, UNIT_TYPE top, UNIT_TYPE right, UNIT_TYPE bottom);
   void add(const ::point_type < NUMBER > & point, const ::size_type < NUMBER > & size);
   void add(const ::size_type < NUMBER > & size);
   void add_if_none_contains(const ::rectangle_type < NUMBER > & rectangle)
   {
      if (!this->any_contains(rectangle)) add(rectangle);
   }
   template < prototype_container CONTAINER >
   void append_if_none_contains(const CONTAINER & container)
   {
      for (auto & r : container) add_if_none_contains(r);
   }
   void intersect(const ::rectangle_type < NUMBER > & rectangle);
   bool any_contains(const ::rectangle_type < NUMBER > & rectangle) const
   {
      for (auto & r : *this) if (r.contains(rectangle)) return true;
      return false;
   }
 
   void add_dim(UNIT_TYPE x, UNIT_TYPE y, UNIT_TYPE cx, UNIT_TYPE cy);
 
   ::collection::index max_normal_intersect_area(const ::rectangle_type < NUMBER > & rectangle, const ::rectangle_type < NUMBER > & rectangleModel);
 
 
   void get_box(::rectangle_type < NUMBER > * prectangle);
   
 
   ::rectangle_type < NUMBER > union_rect();
 
   void offset(UNIT_TYPE cx, UNIT_TYPE cy);
   void offset(::point_type < NUMBER > point);
 
   UNIT_TYPE total_area(::collection::index iStart = 0, ::collection::count c = -1) const
   { 
      
      UNIT_TYPE i = 0; 
      
      this->predicate_each([&i](auto& r)
         {
 
            i += r.area();
 
         }, iStart, c);
            
      return i; 
 
   }
 
   //rectangle_array_base& operator = (const rectangle_array_base& array) { ::array < ::rectangle_type < NUMBER > >::operator=(array); return *this; }
   //rectangle_array_base& operator = (rectangle_array_base&& array) { ::array < ::rectangle_type < NUMBER > >::operator=(::transfer(array)); return *this; }
   //rectangle_array_base& operator = (std::initializer_list < ::rectangle_type < NUMBER > > initializer_list) { ::array < ::rectangle_type < NUMBER > > ::operator=(initializer_list); return *this; }
 
 
};
 
template < prototype_number NUMBER >
inline void rectangle_array_base < NUMBER >::offset(::point_type < NUMBER > point)
{
   offset(point.x, point.y);
}
 
 
 
 
//template < prototype_number NUMBER >
//rectangle_array_base < NUMBER >::~rectangle_array_base()
//{
//
//}
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::offset(UNIT_TYPE cx, UNIT_TYPE cy)
{
 
   for (::i32 i = 0; i < this->get_size(); i++)
   {
 
      ::rectangle_type < NUMBER > & rectangle = this->element_at(i);
 
      rectangle.left += cx;
      rectangle.top += cy;
      rectangle.right += cx;
      rectangle.bottom += cy;
 
   }
 
}
 
 
template < prototype_number NUMBER >
::rectangle_type < NUMBER > rectangle_array_base < NUMBER >::union_rect()
{
   
   if(this->is_empty())
   {
      
      return {};
      
   }
 
   ::rectangle_type < NUMBER > rectangleUnion(0, 0, 0, 0);
 
   rectangleUnion = this->first();
 
   for (::i32 i = 1; i < this->get_size(); i++)
   {
      
      rectangleUnion.unite(rectangleUnion, this->element_at(i));
      //this->element_at(i).expand_bounding_box(rectangleUnion.top_left(), rectangleUnion.bottom_right());
   }
 
   return rectangleUnion;
 
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::get_box(::rectangle_type < NUMBER > * prectangle)
 
{
 
   *prectangle = union_rect();
 
 
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::intersect(const ::rectangle_type < NUMBER > & rectangle)
{
 
   for (::collection::index i = 0; i < this->get_size();)
   {
      
      this->element_at(i).intersect(this->element_at(i), rectangle);
      
      if (this->element_at(i).is_null())
      {
         
         this->erase_at(i);
         
      }
      else
      {
         
         i++;
         
      }
      
   }
 
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::add(const ::rectangle_type < NUMBER > & rectangle)
{
   array_base < ::rectangle_type < NUMBER > >::add(rectangle);
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::add(UNIT_TYPE left, UNIT_TYPE top, UNIT_TYPE right, UNIT_TYPE bottom)
{
   add(::rectangle_type < NUMBER >(left, top, right, bottom));
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::add_dim(UNIT_TYPE x, UNIT_TYPE y, UNIT_TYPE cx, UNIT_TYPE cy)
{
   add(i32_rectangle_dimension(x, y, cx, cy));
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::add(const ::point_type < NUMBER > & point, const ::size_type < NUMBER > & size)
{
   add(::rectangle_type < NUMBER >(point, size));
}
 
 
template < prototype_number NUMBER >
void rectangle_array_base < NUMBER >::add(const ::size_type < NUMBER > & size)
{
   this->add(::rectangle_type < NUMBER >(size));
}
 
 
template < prototype_number NUMBER >
::collection::index rectangle_array_base < NUMBER >::max_normal_intersect_area(const ::rectangle_type < NUMBER > & rectangleParam, const ::rectangle_type < NUMBER > & rectangleModel)
{
 
   ::collection::index iFound = -1;
   ::rectangle_type < NUMBER > rectangle;
   auto iModelArea = rectangleModel.width() * rectangleModel.height();
   decltype(iModelArea) iArea;
   decltype(iModelArea) iAreaMax = 0;
 
   if (iModelArea == 0)
      return -1;
 
   for (::collection::index i = 0; i < this->get_count(); i++)
   {
 
      if (rectangle.intersect(&rectangleParam, this->element_at(i)))
      {
 
         iArea = rectangle.area() * iModelArea / this->element_at(i).area();
 
         if (iArea > iAreaMax)
         {
 
            iFound = i;
 
            iAreaMax = iArea;
 
         }
 
 
      }
 
   }
 
   return iFound;
 
}
 
 
CLASS_DECL_ACME i32_rectangle_array_base get_top_left_oriented_damaged_areas_by_resizing(const ::i32_rectangle & rectangleNew, const ::i32_rectangle & rectangleOld, bool bOnlyGrowing = true);