rect.cpp

LinPacker是一个优化矩形布局的工具

/***************************************************************************
 *   Copyright (C) 2003 by ita                                             *
 *   [e-mail]                                                    *
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#include "rect.h"

Rectangle::Rectangle(int lo, int la, int xpos, int ypos,bool orient,int num,int pos)
{
	longueur = lo;
	largeur = la;
	posx = xpos;
	posy = ypos;
	orientation = orient;
	position = pos;
	numero = num;
};

Rectangle::Rectangle()
{
	longueur = 0;
	largeur = 0;
	posx = 0;
	posy = 0;
	orientation = 0;
	position = 0;
	numero = 0;
};


Rectangle::~Rectangle()
{
};


	int
Rectangle::getLongueur()
{
	if (orientation)
		return longueur;	
	return largeur;
};
	int
Rectangle::getLargeur()
{
	if (orientation)
		return largeur;	
	return longueur;
};

	int
Rectangle::getYHaut()
{
	return (posy + getLongueur());	
};

	int
Rectangle::getXMax()
{
	return (posx + getLargeur());
};


///////////// Divers

	int
Rectangle::recouvre(Rectangle * rect)
{

	if (! rect)
	{
		//cout << "comparaison avec un rectangle nul !!"<<endl;
		return 0;
	}

	float x1,x2,y1,y2;
	float l1,l2,L1,L2; 
	float valx,valy;

	l1 = getLargeur()/2.0;
	l2 = rect->getLargeur()/2.0;
	L1 = getLongueur()/2.0;
	L2 = rect->getLongueur()/2.0;

	x1 = posx  		+	l1;
	x2 = rect->posx	+	l2;
	y1 = posy		+	L1;
	y2 = rect->posy 	+	L2;


	if (x1 < x2)
	{
		valx = x2 - x1;
	}
	else 
	{
		valx = x1 - x2;
	}
	if (y1 < y2)
	{
		valy = y2 - y1;
	}
	else
	{
		valy = y1 - y2;
	}

	//cout <<valx<<" "<<valy<<" - ";
	//cout <<x1<<" "<<x2<<" - ";
	//cout <<y1<<" "<<y2<<" - ";
	//cout <<l1<<" "<<l2<<" - ";
	//cout <<L1<<" "<<L2<<" - "<<endl;

/*
if (valx >(l1 + l2))
	return 0;
if (valy > (L1 + L2) )
	return 0;


return 1;
*/
	

	if ( (valx < (l1 + l2) ) and (valy < (L1 + L2) ) )
	{
		//cout << "superposition de rectangles" <<endl;
		return 1; 
	}
	return 0;

};


	int
Rectangle::getSurface()
{
	return (getLargeur() * getLongueur());
};

////////// lieu

lieu::lieu()
{
	posx=0;
	posy=0;
}

lieu::lieu(int i, int j)
{
	posx=i;
	posy=j;
}

///////// hachage

hash::hash()
{
	idx=0;
	val=0;
}

hash::hash(int i,int j)
{
	idx=i;
	val=j;
}


bool operator< (Rectangle x, Rectangle y)
{
	// attention, relation d'ordre oppos閑 (=>tri inverse)
	return (x.getSurface() > y.getSurface());
}

bool operator< (hash x, hash y)
{
	return (x.val < y.val);
}



/*
   bool operator> (Rectangle x, Rectangle y)
   {
   return (x.getSurface() < y.getSurface());
   }


   bool operator== (Rectangle x, Rectangle y)
   {
   return (x.getSurface() == y.getSurface());
   }
   */