def ellipses(sizes, correlations, mean, variance):
correlation = Correlation()
for size in sizes:
for rho in correlations:
x, y = correlation.multivariate_normal(mean, variance, rho, size)
ellipse = Ellipse(x, y, size, rho)
ellipse.plot()
def update(self):
if len(self.cells) > 0:
self.ellipse = Ellipse(self.cells,
min_ellipse_axis=self.min_ellipse_axis)
for dim in range(0, 2):
self.box[0][dim] = numpy.min([c[dim] for c in self.cells])
self.box[1][dim] = numpy.max([c[dim] for c in self.cells])
def equiprobability_ellipse(capacities):
for capacity in capacities:
_, sp = plt.subplots(1, 3, figsize=(16, 6))
for cor_cov, subplot in zip([0, 0.5, 0.9], sp):
sample = stats.multivariate_normal.rvs([0, 0], [[1, cor_cov], [cor_cov, 1]], capacity)
x = sample[:, 0]
y = sample[:, 1]
ellipse = EllipseClass(0, 0,
1, 1, cor_cov)
subplot.scatter(x, y)
x = np.linspace(min(x) - 2, max(x) + 2, 100)
y = np.linspace(min(y) - 2, max(y) + 2, 100)
x, y = np.meshgrid(x, y)
z = ellipse.z(x, y)
t = ellipse.rad2(sample)
subplot.contour(x, y, z, [ellipse.rad2(sample)])
title = f"n = {capacity} rho = {cor_cov}"
subplot.set_title(title)
subplot.set_xlabel("X")
subplot.set_ylabel("Y")
plt.savefig(f"{capacity}" + f".png")
def extract_ellipses(contours, extract_garbage=True):
ellipses = []
garbage = []
other_contours = []
for c in contours:
if extract_garbage and Ellipse.is_strong_garbage(c):
garbage.append(c)
elif Ellipse.is_strong_ellipse(c):
ellipses.append(c)
else:
other_contours.append(c)
return ellipses, other_contours, garbage
def update_ellipse(self):
self._ellipse = Ellipse(self._init_position, self._final_position,
self._arrival.get_cost() / 2)
self._ellipse_cost_limit = self._arrival.get_cost()
self._outside_nodes = self._outside_nodes + list(
filter(
lambda node: False == self._ellipse.is_point_in(
node.get_position()), self._nodes))
for node in self._outside_nodes:
node.set_outside_state(True)
self._nodes = list(
filter(lambda node: self._ellipse.is_point_in(node.get_position()),
self._nodes))
def ellipseplot(theta,pts):
### Trace les ellipses de corrélation des paramètres pour les param cosmo theta
covarmat = constraints(theta,pts)[1]
fig,axes = plt.subplots(figsize=(15,15),ncols=len(theta)-1,nrows=len(theta)-1,sharex='col', sharey='row')
for i in range(len(theta)-1):
for j in range(len(theta)-1):
if i<j:
axes[i,j].axis('off')
else:
a2=(covarmat[i+1,i+1]+covarmat[j,j])/2 + np.sqrt((covarmat[i+1,i+1]-covarmat[j,j])**2/4 + covarmat[i+1,j]**2)
b2=(covarmat[i+1,i+1]+covarmat[j,j])/2 - np.sqrt((covarmat[i+1,i+1]-covarmat[j,j])**2/4 + covarmat[i+1,j]**2)
a = 1.52*np.sqrt(a2)
b = 1.52*np.sqrt(b2)
#print(a)
#print(b)
tan2T=2*covarmat[i+1,j]/(covarmat[j,j]-covarmat[i+1,i+1])
T=0.5*np.arctan(tan2T)
#print(T*180/np.pi)
ellipse = Ellipse((theta[j],theta[i+1]),a,b,T)
axes[i,j].plot(ellipse[0],ellipse[1],color='darkred', lw=2)
if j==0:
axes[i,j].set_ylabel(name_param[i+1])
if i==4:
axes[i,j].set_xlabel(name_param[j])
if j!=0:
axes[i,j].set_yticklabels([])
if i!=4:
axes[i,j].set_xticklabels([])
fig.savefig('Figures/error_figs_tau/cov_plot.png',dpi=300)
def __init__(self, imageId, major_axis, minor_axis, speed, rot_speed, size, textureMoon=None, moonOrbitParams=None):
self.texture = Texture(imageId)
self.qobj = gluNewQuadric()
gluQuadricTexture(self.qobj, GL_TRUE)
self.ellipse = Ellipse(major_axis, minor_axis, speed)
self.rotation = 0
self.lastCoords = 0
self.rot_speed = rot_speed
self.size = size
if(textureMoon is None):
self.moon = False
else:
self.moon = True
self.textureMoon = Texture(textureMoon)
self.moonSize = moonOrbitParams[2]
self.moonOrbit = Ellipse(moonOrbitParams[0], moonOrbitParams[0], moonOrbitParams[1])
def curve():
# Get current and desired points for ellipse generation
cur_point = gps.getValues()
point_to = gps.getValues()
point_to[0] -= curve_sep
# Make ellipse from points
ellipse = Ellipse(cur_point, point_to)
to_travel = ellipse.ellipse_points
# Take x,z coord pairs and have robot drive to each one
for x, z in to_travel:
# Finding correct angle to drive on
cur_point = gps.getValues()
# Calculate the distance between current location and (x,z)
dist = math.sqrt((cur_point[0] - x)**2 + (cur_point[2] - z)**2)
# Calculate the abs(x_diff) between current location and (x,z)
x_diff = abs(cur_point[0] - x)
# Calculate angle from x axis for proper travel (radians)
theta = math.acos(x_diff / dist)
# Convert to degrees
theta = theta * (180 / math.pi)
# Adjust theta based on which moving up or down
if z < cur_point[2]:
theta += 90
else:
theta = 90 - theta
# Adjust to new angle
adjust_to_angle_degrees(theta)
# Drive to point
drive_to_point_ellipse([x, 0, z])
# Reset to line for next curve or final step
adjust_to_angle_degrees(90)
def __init__(self, x, y, mode, fileName, scene, parent=None):
super(AddItemCommand, self).__init__(parent)
from designerscene import DesignerScene
from rectangle import Rectangle
from ellipse import Ellipse
from text import Text
from bitmap import Bitmap
from vectorgraphic import Vectorgraphic
self.scene = scene
self.item = None
if mode == DesignerScene.RECTANGLE:
self.item = Rectangle(self.scene)
self.item.setId("Rectangle")
self.item.setPen(QPen(Qt.black))
self.item.setBrush(QBrush(Qt.blue))
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.item.setWidth(50)
self.item.setHeight(50)
self.setText("Add Rectangle")
elif mode == DesignerScene.ELLIPSE:
self.item = Ellipse(self.scene)
self.item.setId("Ellipse")
self.item.setPen(QPen(Qt.black))
self.item.setBrush(QBrush(Qt.blue))
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.item.setWidth(50)
self.item.setHeight(50)
self.setText("Add Ellipse")
elif mode == DesignerScene.TEXT:
self.item = Text("Lorem ipsum dolor", self.scene)
self.item.setId("Text")
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.setText("Add Text")
elif mode == DesignerScene.BITMAP:
self.item = Bitmap(fileName, self.scene)
self.item.setId("Bitmap")
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.setText("Add Bitmap")
elif mode == DesignerScene.SVG:
self.item = Vectorgraphic(fileName, self.scene)
self.item.setId("Vectorgraphic")
self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.item.setPos(x, y)
self.setText("Add Vectorgraphic")
def __init__(self, start, goal, search_range, domain, collision_manager,
controller, informed, kinodynamic, initial_state, max_iters,
seed):
self.start = start
self.goal = goal
self.graph = Graph(start, goal, state0=initial_state)
self.x_domain, self.y_domain, self.z_domain = domain
self.search_range = search_range
self.collision_manager = collision_manager
self.controller = controller
self.informed = informed
self.kinodynamic = kinodynamic
self.max_iters = max_iters
self.ellipse = Ellipse(start, goal, domain=domain)
np.random.seed(seed)
def AddShape(self, e: wx.MouseEvent):
if self.FindWindow("Shape").Value == "Line":
self.shapes.append(Line(self.CurrentPen, e.x, e.y))
elif self.FindWindow("Shape").Value == "Rectangle":
self.shapes.append(Rectangle(self.CurrentPen, e.x, e.y))
elif self.FindWindow("Shape").Value == "Ellipse":
self.shapes.append(Ellipse(self.CurrentPen, e.x, e.y))
elif self.FindWindow("Shape").Value == "Circle":
self.shapes.append(Circle(self.CurrentPen, e.x, e.y))
def __extract_strong_ellipses(contours):
strong = []
not_ellipses = []
for c in contours:
if Ellipse.is_strong_ellipse(c):
strong.append(c)
else:
not_ellipses.append(c)
return strong, not_ellipses
def __init__(self, detail_return):
# Filters parameters
self.whitening = 0.2
self.size_filter_gaussian = (9, 9)
self.type_gaussian = 0
self.size_median = 3
self.thresh_threshold = 25
self.maxvalue_threshold = 255
self.kernel_size_morphology = ((5, 5), (7, 7), (10, 10), (12, 12),
(15, 15), (17, 17))
self.color_circle = (255, 255, 0)
self.thickness_circle = 3
self.position_text = (120, 30)
self.font_text = cv2.FONT_HERSHEY_DUPLEX
self.font_scale = 0.2
self.min_area = 50000
self.ellipse = Ellipse()
self.noise = Noise(self.min_area)
def plot_subplanck(theta,pts):
constr = constraints(theta,pts)
std_l= constr[0]
fig = plt.figure(figsize=(15,7.5))
for i in range(len(theta)):
ax = fig.add_subplot(231+i)
ax.grid(True,linestyle='dotted')
stds = std_l[i]
textstr = r'$\frac{\sigma_p}{\sigma_F} =$ '+str(round(planck_values[i]/stds,3))
props = dict(boxstyle='round',facecolor='white')
ax.text(0.05,0.95,textstr,transform=ax.transAxes,verticalalignment='top',bbox=props)
abs = np.linspace(theta[i]-4*planck_values[i],theta[i]+4*planck_values[i],500)
ord = gaussian(abs,theta[i],stds)
ord2 = gaussian(abs,theta[i],planck_values[i])
ax.plot(abs,ord/np.max(ord),color='darkred',label ="Fischer")
ax.plot(abs,ord2/np.max(ord2),color='darkblue',label="Planck")
ax.set_xlabel(name_param[i])
handles, labels = ax.get_legend_handles_labels()
fig.legend(handles, labels, loc='upper right')
fig.suptitle(r'$L_{max}$ = '+str(pts))
if not(os.path.isdir('Figures/error_figs_tau')):
os.mkdir('Figures/error_figs_tau/')
fig.savefig('Figures/error_figs_tau/error_plot.png',dpi=300)
covarmat = constr[1]
fig,axes = plt.subplots(figsize=(15,15),ncols=len(theta)-1,nrows=len(theta)-1)
for i in range(len(theta)-1):
for j in range(len(theta)-1):
if i<j:
axes[i,j].axis('off')
else:
a2=(covarmat[i+1,i+1]+covarmat[j,j])/2 + np.sqrt((covarmat[i+1,i+1]-covarmat[j,j])**2/4 + covarmat[i+1,j]**2)
b2=(covarmat[i+1,i+1]+covarmat[j,j])/2 - np.sqrt((covarmat[i+1,i+1]-covarmat[j,j])**2/4 + covarmat[i+1,j]**2)
a = 1.52*np.sqrt(a2)
b = 1.52*np.sqrt(b2)
#print(a)
#print(b)
tan2T=2*covarmat[i+1,j]/(covarmat[j,j]-covarmat[i+1,i+1])
T=0.5*np.arctan(tan2T)
#print(T*180/np.pi)
ellipse = Ellipse((theta[j],theta[i+1]),a,b,T)
axes[i,j].plot(ellipse[0],ellipse[1],color='darkred', lw=2)
if j==0:
axes[i,j].set_ylabel(name_param[i+1])
if i==4:
axes[i,j].set_xlabel(name_param[j])
if j!=0:
axes[i,j].set_yticklabels([])
if i!=4:
axes[i,j].set_xticklabels([])
fig.savefig('Figures/error_figs_tau/cov_plot.png',dpi=300)
return(constr)
def copy_shape(shape):
"""Create and return a deep copy of the passed shape"""
if type(shape) == Circle:
return Circle(shape.center, shape.radius)
if type(shape) == Ellipse:
return Ellipse(shape.center, shape.half_width, shape.half_height, shape.polygon)
return copy.deepcopy(shape)
def drawEllipse(self, qp):
pen = QPen(Qt.black, 2, Qt.SolidLine)
qp.setPen(pen)
size = self.size()
if self.position is not None:
self.points = Ellipse(self.position, size)
if self.index < len(self.points):
self.outPoints.append(self.points[self.index])
self.index += 1
# 用index调控每一次要输出的数目
for outPoint in self.outPoints:
qp.drawPoint(outPoint[0], outPoint[1])
class Asteroid:
def __init__(self, fire):
self.asteroid = OBJ("asteroid.obj", textureFile="asteroid.jpg")
self.ellipse = Ellipse(18, 4, 0.17)
self.fire = fire
self.angle = 0
def draw(self):
coords = self.ellipse.getCoords()
glPushMatrix()
glTranslatef(13.0, 0.0, 8.0)
glRotatef(35, 0.0, 1.0, 0.0)
self.ellipse.render()
glTranslatef(coords[0], 0, coords[1] - 0.35)
glPushMatrix()
glScalef(0.0006, 0.0006, 0.0006)
self.asteroid.render()
glPopMatrix()
glRotatef(90, 0, 0, 1)
glRotatef(90 * math.sin(math.radians(self.angle)), 1.0, 0.0, 0.0)
self.fire.drawSystem()
glPopMatrix()
self.angle += 0.17
def update(self):
"""
performs update of all single shape until convergence or termination
picks shape that minimises loss
"""
#init centroid
centroid = self.pick_centroid()
if (centroid == None):
return
#pick shape and init and init at centroid
shapes = [
Rectangle([centroid, 1, 1, 0]),
Ellipse([centroid, 3, 3]),
Triangle([
centroid, (centroid[0] + 2, centroid[1]),
((centroid[0] + 1, centroid[1] + 2))
])
]
shapes_losses = []
old_loss = self.current_loss()
for shape in shapes:
current_loss = self.current_loss()
for i in range(0, N_ITERATIONS):
old_shape = copy.deepcopy(shape)
shape.update_params()
self.shapes.append(shape)
new_loss = self.current_loss()
if (new_loss > current_loss):
shape = copy.deepcopy(old_shape)
else:
current_loss = new_loss
del self.shapes[-1]
shapes_losses.append((shape, current_loss))
min_shape_idx = np.argmin([x[1] for x in shapes_losses])
min_loss = shapes_losses[min_shape_idx][1]
print(min_loss)
if ((min_loss >= old_loss) and (len(self.shapes) > 0)):
return
else:
self.shapes.append(shapes_losses[min_shape_idx][0])
class Planet:
def __init__(self, imageId, major_axis, minor_axis, speed, rot_speed, size, textureMoon=None, moonOrbitParams=None):
self.texture = Texture(imageId)
self.qobj = gluNewQuadric()
gluQuadricTexture(self.qobj, GL_TRUE)
self.ellipse = Ellipse(major_axis, minor_axis, speed)
self.rotation = 0
self.lastCoords = 0
self.rot_speed = rot_speed
self.size = size
if(textureMoon is None):
self.moon = False
else:
self.moon = True
self.textureMoon = Texture(textureMoon)
self.moonSize = moonOrbitParams[2]
self.moonOrbit = Ellipse(moonOrbitParams[0], moonOrbitParams[0], moonOrbitParams[1])
def draw(self):
coords = self.ellipse.getCoords()
glPushMatrix()
glTranslatef(coords[0], 0.0, coords[1])
self.lastCoords = coords
if(self.moon):
glPushMatrix()
self.moonOrbit.render()
coords = self.moonOrbit.getCoords()
glTranslatef(coords[0], 0.0, coords[1])
glScalef(self.moonSize, self.moonSize, self.moonSize)
glBindTexture(GL_TEXTURE_2D, self.textureMoon.textureId)
gluSphere(self.qobj, 1, 50, 50)
glPopMatrix()
glRotatef(270, 1.0, 0.0, 0.0)
glRotatef(self.rotation, 0.0, 0.0, 1.0)
glScalef(self.size, self.size, self.size)
glBindTexture(GL_TEXTURE_2D, self.texture.textureId)
gluSphere(self.qobj, 1, 50, 50)
glPopMatrix()
self.ellipse.render()
self.rotation += self.rot_speed
class Filters:
def __init__(self, detail_return):
# Filters parameters
self.whitening = 0.2
self.size_filter_gaussian = (9, 9)
self.type_gaussian = 0
self.size_median = 3
self.thresh_threshold = 25
self.maxvalue_threshold = 255
self.kernel_size_morphology = ((5, 5), (7, 7), (10, 10), (12, 12),
(15, 15), (17, 17))
self.color_circle = (255, 255, 0)
self.thickness_circle = 3
self.position_text = (120, 30)
self.font_text = cv2.FONT_HERSHEY_DUPLEX
self.font_scale = 0.2
self.min_area = 50000
self.ellipse = Ellipse()
self.noise = Noise(self.min_area)
def pupil_analysis(self, frame, nember_frame):
if frame is None:
raise Exception("Frame is none!")
original = np.copy(frame[:, :, 0])
yuv = cv2.cvtColor(frame, cv2.COLOR_BGR2YUV)
yuv[:, :, 0] = cv2.equalizeHist(yuv[:, :, 0])
bgr = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)
gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
gaussian = cv2.GaussianBlur(gray, self.size_filter_gaussian,
self.type_gaussian)
median = cv2.medianBlur(gaussian, self.size_median)
final = np.copy(gray)
for size in self.kernel_size_morphology:
kernel = np.ones(size, np.uint8)
erode = cv2.erode(median, kernel=kernel, iterations=1)
dilate = cv2.dilate(erode, kernel=kernel, iterations=1)
threshold = cv2.threshold(dilate, self.thresh_threshold,
self.maxvalue_threshold,
cv2.THRESH_BINARY)[1]
contours, _ = cv2.findContours(threshold, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours,
key=lambda x: cv2.contourArea(x),
reverse=True)
center, radius = self.ellipse.search_ellipse(image=threshold,
contours=contours)
if center is not None and radius > 0:
cv2.circle(final, center, radius, self.color_circle,
self.thickness_circle)
break
images = {
'gray': gray,
'gaussian': gaussian,
'median': median,
'erode': erode,
'dilate': dilate
}
return center, radius, images
def write_radius(self, frame, radius):
cv2.putText(frame, "radius: %d" % radius, self.position_text,
self.font_text, 1, self.color_circle)
return frame
@staticmethod
def resize(figure):
return cv2.resize(figure, (0, 0), fx=0.5, fy=0.5)
def __str__(self):
return ('%s: (%d, %d), area=%.2f, r=%d' % (self.name, self.centre_x, self.centre_y,Ellipse.area(self), self.radius_x))
def __init__(self, centre_x, centre_y, radius,name = 'Circle'):
Ellipse.__init__(self, centre_x, centre_y,radius, radius, name)
def testInsideEllipse():
rect0 = {(2, 2), (3, 2), (6, 2), (7, 2), (8, 2), (2, 3), (3, 3), (6, 3),
(7, 3), (8, 3), (2, 4), (3, 4), (6, 4), (7, 4), (8, 4), (2, 5),
(3, 5), (4, 5), (5, 5), (6, 5), (7, 5), (8, 5)}
rect1 = {(3, 2), (3, 3), (2, 4), (3, 4), (4, 5), (3, 5), (4, 6), (3, 6)}
rect2 = {(2, 4), (3, 4), (4, 5), (3, 5), (4, 6), (3, 6), (4, 7)}
rect3 = {(4, 3), (4, 4), (5, 3), (5, 4)}
c0 = Cluster(rect0)
c1 = Cluster(rect1)
c2 = Cluster(rect2)
c3 = Cluster(rect3)
ell0 = Ellipse(c0.cells, min_ellipse_axis=6)
ell1 = Ellipse(c1.cells, min_ellipse_axis=6)
ell2 = Ellipse(c2.cells, min_ellipse_axis=6)
ell3 = Ellipse(c3.cells, min_ellipse_axis=6)
if ell1.isEllipseInsideOf(ell0, 1.0):
print 'ell1 is inside of ell0'
if ell2.isEllipseInsideOf(ell1, 0.8):
print 'ell2 is inside of ell1'
if ell3.isEllipseInsideOf(ell0, 0.8):
print 'ell3 is inside of ell0'
if ell0.isEllipseInsideOf(ell3, 0.8):
print 'ell0 is inside of ell3'
def testAngle():
rect0 = {(2, 3), (3, 3), (4, 3), (5, 3), (6, 3), (7, 3), (8, 3), (2, 4),
(3, 4), (4, 4), (5, 4), (6, 4), (7, 4), (8, 4), (2, 5), (3, 5),
(4, 5), (5, 5), (6, 5), (7, 5), (8, 5), (2, 6), (3, 6), (4, 6),
(5, 6), (6, 6), (7, 6), (8, 6)}
rect1 = {(2, 3), (3, 3), (2, 4), (3, 4), (2, 5), (3, 5), (2, 6), (3, 6)}
rect2 = {(4, 6), (4, 7), (2, 4), (3, 4), (2, 5), (3, 5), (2, 6), (3, 6)}
rect3 = {(2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4)}
rect4 = {(2, 2), (2, 3), (2, 4), (1, 4)}
c0 = Cluster(rect0)
c1 = Cluster(rect1)
c2 = Cluster(rect2)
c3 = Cluster(rect3)
c4 = Cluster(rect4)
ell0 = Ellipse(c0.cells, min_ellipse_axis=1)
print 'c0', ell0.centre, ell0.a, ell0.b, ell0.angle
ell0.show()
ell1 = Ellipse(c1.cells, min_ellipse_axis=1)
print 'c1', ell1.centre, ell1.a, ell1.b, ell1.angle
ell1.show()
ell2 = Ellipse(c2.cells, min_ellipse_axis=1)
print 'c2', ell2.centre, ell2.a, ell2.b, ell2.angle
ell2.show()
ell3 = Ellipse(c3.cells, min_ellipse_axis=1)
print 'c3', ell3.centre, ell3.a, ell3.b, ell3.angle
ell3.show()
ell4 = Ellipse(c4.cells, min_ellipse_axis=1)
print 'c4', ell4.centre, ell4.a, ell4.b, ell4.angle
ell4.show()
def create_knapsack_packing_problems_with_manual_solutions(can_print=False):
"""Create a set of Knapsack-Packing problem instances that are solved (optimally) with manual placements (using actions available for all the algorithms); both the problems and solutions are returned"""
problems, solutions = list(), list()
start_time = time.time()
# Problem 1
max_weight = 120.
container_shape = Circle((3.3, 3.3), 3.3)
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0, 0), (0, 4.5), (4.5, 4.5), (4.5, 0)]), 40., 50.),
Item(Circle((0, 0), 0.45), 20., 5.),
Item(Circle((0, 0), 0.45), 20., 10.),
Item(Circle((0, 0), 0.45), 20., 15.),
Item(Circle((0, 0), 0.45), 20., 20.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (3.3, 3.3), 0.), can_print)
print_if_allowed(solution.add_item(1, (3.3, 6.05), 0.), can_print)
print_if_allowed(solution.add_item(2, (3.3, 0.55), 0.), can_print)
print_if_allowed(solution.add_item(3, (6.05, 3.3), 0.), can_print)
print_if_allowed(solution.add_item(4, (0.55, 3.3), 0.), can_print)
# Problem 2
max_weight = 100.
container_shape = Point(5, 5).buffer(5, 4)
container = Container(max_weight, container_shape)
items = [Item(MultiPolygon([(Point(5, 5).buffer(4.7, 4).exterior.coords,
[tuple(Point(5, 5).buffer(4, 4).exterior.coords)])]), 10., 25.),
Item(MultiPolygon([(Point(5, 5).buffer(3.7, 4).exterior.coords,
[tuple(Point(5, 5).buffer(3, 4).exterior.coords)])]), 10., 15.),
Item(MultiPolygon([(Point(5, 5).buffer(2.7, 4).exterior.coords,
[tuple(Point(5, 5).buffer(2, 4).exterior.coords)])]), 10., 20.),
Item(MultiPolygon([(Point(5, 5).buffer(1.7, 4).exterior.coords,
[tuple(Point(5, 5).buffer(1, 4).exterior.coords)])]), 20., 20.),
Item(Circle((0., 0.), 0.7), 20., 10)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (5., 5.), 0.), can_print)
print_if_allowed(solution.add_item(1, (5., 5.), 0.), can_print)
print_if_allowed(solution.add_item(2, (5., 5.), 0.), can_print)
print_if_allowed(solution.add_item(3, (5., 5.), 0.), can_print)
print_if_allowed(solution.add_item(4, (5., 5.), 0.), can_print)
# Problem 3
max_weight = 32.
container_shape = Polygon([(0, 0), (0, 10), (10, 10), (10, 0)])
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0, 0), (0, 6.), (6., 0)]), 10., 20.),
Item(Polygon([(0, 0), (0, 6.), (6., 0)]), 10., 10.),
Item(Ellipse((0, 0), 1.5, 0.3), 10., 5.),
Item(Ellipse((0, 0), 3, 0.3), 5., 5.),
Item(Ellipse((0, 0), 1.5, 0.3), 5., 5.),
Item(Ellipse((0, 0), 3, 0.3), 10., 5.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (4.99, 5), 0.), can_print)
print_if_allowed(solution.add_item(1, (5.01, 5), 180.), can_print)
print_if_allowed(solution.add_item(3, (5., 1.65), 0), can_print)
print_if_allowed(solution.add_item(4, (5., 8.35), 0), can_print)
# Problem 4
max_weight = 50.
container_shape = Ellipse((3., 2.), 3., 2.)
container = Container(max_weight, container_shape)
items = [Item(Ellipse((0., 0.), 0.7, 0.5), 5., 7),
Item(Ellipse((0., 0.), 0.3, 0.1), 7., 2),
Item(Ellipse((0., 0.), 0.2, 0.4), 8., 4),
Item(Ellipse((0., 0.), 0.5, 0.3), 3., 5),
Item(Circle((0., 0.), 0.4), 4., 5),
Item(Circle((0., 0.), 0.25), 3., 2),
Item(Circle((0., 0.), 0.2), 9., 5),
Item(Circle((0., 0.), 0.1), 4., 3.),
Item(Circle((0., 0.), 0.7), 9., 3.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (3., 1.94), 0.), can_print)
print_if_allowed(solution.add_item(2, (3., 3.24), 90.), can_print)
print_if_allowed(solution.add_item(3, (3., 2.74), 0.), can_print)
print_if_allowed(solution.add_item(4, (2.25, 3.5), 0.), can_print)
print_if_allowed(solution.add_item(5, (3., 3.71), 0.), can_print)
print_if_allowed(solution.add_item(6, (3.46, 3.75), 0.), can_print)
print_if_allowed(solution.add_item(7, (3.44, 3.43), 0.), can_print)
print_if_allowed(solution.add_item(8, (3., 0.72), 0.), can_print)
# Problem 5
max_weight = 100.
container_shape = MultiPolygon([(((0, 0), (0.5, 3), (0, 5), (5, 4.5), (5, 0)),
[((0.1, 0.1), (0.1, 0.2), (0.2, 0.2), (0.2, 0.1)),
((0.3, 0.3), (0.3, 1.2), (1.6, 2.9), (0.75, 0.4)),
((3.1, 1.5), (3.5, 4.5), (4.9, 4.4), (4.8, 1.2))])])
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0, 0), (1, 1), (1, 0)]), 15., 32.),
Item(Polygon([(1, 2), (1.5, 3), (4, 5), (1, 4)]), 30., 100.),
Item(MultiPolygon([(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)),
[((0.1, 0.1), (0.1, 0.2), (0.2, 0.2), (0.2, 0.1)),
((0.3, 0.3), (0.3, 0.6), (0.6, 0.6), (0.6, 0.4))])]), 12., 30.),
Item(Polygon([(0.1, 0.1), (0.1, 0.2), (0.2, 0.2)]), 10., 10.),
Item(MultiPolygon([(((0., 0.), (0., 1.4), (2., 1.3), (2., 0.)),
[((0.1, 0.1), (0.1, 0.15), (0.15, 0.15), (0.15, 0.1)),
((0.2, 0.2), (0.2, 1.2), (1.8, 1.1), (1.8, 0.2))
])]), 1., 5.),
Item(Circle((0., 0.), 0.4), 1., 14.),
Item(Circle((0., 0.), 0.1), 2., 12.),
Item(Ellipse((0., 0.), 0.5, 0.2), 3., 12.),
Item(Polygon([(0., 0.), (0., 0.3), (0.3, 0.3)]), 1., 10.),
Item(Ellipse((0., 0.), 0.8, 0.3), 10., 12.),
Item(Ellipse((0., 0.), 0.1, 0.05), 1., 2.),
# random items
# Item(shape_functions.create_random_polygon(0, 0, 0.8, 0.8, 10), 1., 5.),
# Item(shape_functions.create_random_triangle_in_rectangle_corner(0, 0, 0.8, 0.8), 1., 5.),
# Item(shape_functions.create_random_quadrilateral_in_rectangle_corners(0, 0, 0.8, 0.8), 1., 5.),
# out-items
Item(Circle((0., 0.), 0.2), 50., 1.),
]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
# solution.visualize()
# print(solution.add_item(0, (1.2, 0.5), 150.))
print_if_allowed(solution.add_item(0, (1.2, 0.5), 0.), can_print)
print_if_allowed(solution.add_item(1, (2., 3.), 0.), can_print)
print_if_allowed(solution.add_item(2, (2.5, 2.5), 0.), can_print)
print_if_allowed(solution.move_item_in_direction(2, (1, -1), evolutionary.MUTATION_MODIFY_MOVE_UNTIL_INTERSECTION_POINT_NUM, evolutionary.MUTATION_MODIFY_MOVE_UNTIL_INTERSECTION_MIN_DIST_PROPORTION, 9999), can_print)
print_if_allowed(solution.add_item(3, (2.5, 2.4), 0.), can_print)
print_if_allowed(solution.add_item(4, (3., 0.7), 0.), can_print)
print_if_allowed(solution.add_item(5, (3.03, 0.73), 0.), can_print)
print_if_allowed(solution.add_item(6, (3.45, 1.02), 0.), can_print)
print_if_allowed(solution.add_item(7, (3., 3.82), 45.), can_print)
print_if_allowed(solution.add_item(8, (2.4, 0.7), 0.), can_print)
print_if_allowed(solution.move_item(0, (0.29, 0)), can_print)
# print_if_allowed(solution.move_item_to(0, (1.49, 2.5)), can_print)
print_if_allowed(solution.rotate_item_to(0, 180.), can_print)
print_if_allowed(solution.rotate_item(0, 90.), can_print)
# print_if_allowed(solution.remove_item(0), can_print)
# print_if_allowed(solution.rotate_item(4, 20), can_print)
# print_if_allowed(solution.move_item(7, (1, 0)), can_print)
# print_if_allowed(solution.rotate_item(7, -45), can_print)
# print_if_allowed(solution.move_item(5, (-0.4, 0)), can_print)
print_if_allowed(solution.add_item(9, (1.2, 4.07), 15.), can_print)
print_if_allowed(solution.add_item(10, (3.6, 0.45), 30.), can_print)
# print_if_allowed(solution.add_item(11, (4.5, 0.5), 0.), can_print)
# Problem 6
max_weight = 150.
container_shape = MultiPolygon([(((0., 0.), (5., 0.), (5., 5.), (0., 5.)),
[((0.7, 0.7), (1.5, 0.7), (1.5, 1.5), (0.7, 1.5)),
((2.4, 0.3), (4.3, 0.3), (4.3, 4.3), (2.4, 4.3)),
((0.7, 2.7), (1.5, 2.7), (1.5, 3.5), (0.7, 3.5))])])
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0., 0.), (1.6, 0.), (1.4, 0.2), (1.7, 1.)]), 6., 13.),
Item(Polygon([(0., 0.), (1.6, 3.), (2.8, 2.9), (1.5, 2.7), (1.9, 1.6)]), 11., 12.),
Item(Polygon([(0., 0.), (1.8, 1.5), (0., 2.8)]), 15., 25.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.2), (0., 0.2)]), 14., 10.),
Item(Polygon([(0., 0.), (2.5, 0.), (1.5, 0.2), (0., 0.2)]), 10., 12.),
Item(Polygon([(0., 0.), (1.6, 0.), (0.8, 0.45), (0.6, 0.7), (0., 0.45)]), 17., 8.),
Item(Polygon([(0., 0.), (1.5, 0.), (0.8, 0.15), (0., 0.1)]), 13., 12.),
Item(Polygon([(0., 0.), (1.5, 0.), (0.8, 0.15), (0., 0.1)]), 15., 7.),
Item(Ellipse((0., 0.), 0.5, 0.3), 15., 8.),
Item(Ellipse((0., 0.), 0.2, 0.8), 14., 21.),
Item(Circle((0., 0.), 0.2), 18., 18.),
Item(Circle((0., 0.), 0.6), 11., 12.),
Item(Circle((0., 0.), 0.35), 12., 9.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (0.9, 2.02), 0.), can_print)
print_if_allowed(solution.add_item(3, (0.78, 0.12), 0.), can_print)
print_if_allowed(solution.add_item(4, (2.8, 0.12), 0.), can_print)
print_if_allowed(solution.add_item(5, (0.8, 3.85), 0.), can_print)
print_if_allowed(solution.add_item(6, (0.78, 0.3), 0.), can_print)
print_if_allowed(solution.add_item(7, (2.3, 2.57), 90.), can_print)
print_if_allowed(solution.add_item(8, (0.3, 2.98), 90.), can_print)
print_if_allowed(solution.add_item(9, (2.17, 1.05), 0.), can_print)
print_if_allowed(solution.add_item(10, (1.8, 0.45), 0.), can_print)
print_if_allowed(solution.add_item(11, (1.77, 4.38), 0.), can_print)
print_if_allowed(solution.add_item(12, (0.35, 4.63), 0.), can_print)
# Problem 7
max_weight = 122.
container_shape = Polygon([(3.5, 0.6), (0.5, 0.9), (3.7, 5.5), (1.7, 4.), (0., 6.5), (0.2, 8.6), (0.8, 9.8), (1.7, 8.9), (2, 9.1), (4.4, 9.3), (4.2, 6.7), (4.9, 7.5), (6.5, 8.4), (6.6, 7.9), (7.4, 8.2), (8.7, 5.5), (9.3, 4.8), (6.3, 0.2), (5., 3.5), (5, 0.7), (3.5, 0.6)])
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0, 3), (0, 2.), (4., 0)]), 5., 6.),
Item(Polygon([(0, 0), (1., 2.), (2.5, 2), (1, 1.2)]), 10., 7.),
Item(Polygon([(0, 1), (1, 2.), (3., 0)]), 9., 4.),
Item(Polygon([(0, 0.5), (1, 1.), (3, 1), (2., 0)]), 19., 14.),
Item(Polygon([(0, 0.6), (2, 1), (2., 1.5), (1.2, 1.5)]), 19., 15.),
Item(Polygon([(0, 0), (0, 2.), (0.5, 2), (0.5, 0.5), (2.5, 0.5), (2.5, 0)]), 7., 15.),
Item(MultiPolygon([(((0.0, 0.0), (0.0, 1.8), (1.0, 2.7), (2.3, 0.0)),
[((0.2, 0.2), (0.2, 1.4), (0.7, 2.1), (1.8, 0.5))])]), 12., 6.),
Item(MultiPolygon([(((0.0, 0.0), (1.0, 1.8), (2.0, 2.5), (2.6, 0.7)),
[((0.2, 0.2), (1.2, 1.4), (2.1, 1.7))])]), 7., 13.),
Item(Ellipse((0, 0), 0.5, 0.2), 4., 9.),
Item(Ellipse((0, 0), 0.2, 1.5), 21., 14.),
Item(Ellipse((0, 0), 2.5, 3.5), 16., 30.),
Item(Circle((0, 0), 0.4), 7., 12.),
Item(Circle((0, 0), 0.3), 10., 3.),
Item(Circle((0, 0), 1.), 1., 3.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (5.73, 3.02), 318.), can_print)
print_if_allowed(solution.add_item(1, (6.3, 4.1), 40.), can_print)
print_if_allowed(solution.add_item(2, (4.58, 2.5), 315.), can_print)
print_if_allowed(solution.add_item(3, (1.3, 5.4), 320.), can_print)
print_if_allowed(solution.add_item(4, (1.4, 1.7), 20.), can_print)
print_if_allowed(solution.add_item(5, (2.9, 7.9), 180.), can_print)
print_if_allowed(solution.add_item(6, (8.2, 4), 300.), can_print)
print_if_allowed(solution.add_item(7, (2.5, 7.4), 340.), can_print)
print_if_allowed(solution.add_item(8, (7.3, 4.), 320.), can_print)
print_if_allowed(solution.add_item(9, (2.9, 3.9), 330.), can_print)
print_if_allowed(solution.add_item(11, (7.8, 4.4), 0.), can_print)
print_if_allowed(solution.add_item(13, (6.2, 6.8), 0.), can_print)
# Problem 8
max_weight = 100.
container_shape = Polygon([(0., 0.), (0., 5.), (2.5, 3.4), (5., 5.), (5., 0), (2.5, 1.6)])
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0., 0.), (0., 3.), (0.25, 3.), (0.25, 0.25), (2., 2.5), (3.75, 0.25), (3.75, 3.), (4., 3.), (4., 0.), (3.75, 0.), (2., 2.), (0.25, 0.)]), 100., 100.),
Item(Polygon([(0., 0.), (1.6, 1.), (1.8, 1.9), (0.9, 1.6)]), 11., 12.),
Item(Polygon([(0., 0.), (1.8, 2.5), (0., 1.8)]), 15., 5.),
Item(Polygon([(0., 0.), (0.5, 0.), (1.2, 0.4), (0., 0.5)]), 4., 10.),
Item(Polygon([(0., 0.), (2.5, 0.), (1.5, 0.2), (0., 0.5)]), 1., 2.),
Item(Polygon([(0., 0.), (0.7, 0.25), (1.6, 1.5), (0.6, 0.7), (0., 0.45)]), 17., 8.),
Item(Polygon([(0., 0.), (0.8, 0.5), (1.5, 1.2), (0., 0.5)]), 13., 11.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.2, 0.6), (0., 0.3)]), 15., 7.),
Item(Ellipse((0., 0.), 0.6, 0.4), 15., 8.),
Item(Ellipse((0., 0.), 2., 0.5), 15., 8.),
Item(Ellipse((0., 0.), 0.5, 0.3), 24., 6.),
Item(Ellipse((0., 0.), 0.4, 0.1), 4., 3.),
Item(Circle((0., 0.), 0.6), 11., 2.),
Item(Circle((0., 0.), 0.35), 12., 4.),
Item(Circle((0., 0.), 0.2), 18., 8.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (2.5, 2.02), 0.), can_print)
# Problem 9
max_weight = 200.
container_shape = Point(5, 5).buffer(5, 3)
container = Container(max_weight, container_shape)
items = [Item(MultiPolygon([(Point(5, 5).buffer(4.7, 2).exterior.coords,
[((9., 5.), (5., 1.), (1., 5.), (5., 9.))])]), 120., 110.),
Item(Polygon([(0., 0.), (0., 5.), (5., 5.), (5., 0.)]), 50., 80.),
Item(Polygon([(1., 4.2), (1.5, 2.), (4., 0)]), 15., 14.),
Item(Polygon([(0, 0), (1., 2.), (2.5, 2), (1, 1.2)]), 11., 11.),
Item(Polygon([(0, 1), (1, 2.), (3., 0)]), 11., 4.),
Item(Polygon([(0, 0.5), (1, 1.), (3, 1), (2., 0)]), 19., 14.),
Item(Polygon([(0, 0.4), (1.8, .8), (1.5, 1.3), (1.2, 3.3)]), 17., 15.),
Item(Polygon([(0, 0), (0, 2.), (0.9, 2), (0.9, 0.5), (1.5, 0.5), (1.5, 0)]), 70., 15.),
Item(Ellipse((0, 0), 0.8, 1.2), 14., 13.),
Item(Ellipse((0, 0), 1.2, 1.5), 12., 6.),
Item(Ellipse((0, 0), 2.5, 1.7), 16., 10.),
Item(Circle((0, 0), 0.7), 17., 11.),
Item(Circle((0, 0), 0.8), 13., 10.),
Item(Circle((0, 0), 1.), 4., 4.),
Item(Circle((0, 0), 2.), 22., 8.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (5., 5.), 0.), can_print)
print_if_allowed(solution.add_item(1, (5., 5.), 45.), can_print)
# Problem 10
max_weight = 150.
container_shape = Polygon([(2., 5.), (3., 5), (3., 3.), (5., 3.), (5., 2.), (3., 2.), (3., 0.), (2., 0.), (2., 2.), (0., 2.), (0., 3.), (2., 3.)])
container = Container(max_weight, container_shape)
items = [Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95)]), 10., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95), (0., 0.95)]), 20., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95), (0., 0.95)]), 20., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95), (0., 0.95)]), 20., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95), (0., 0.95)]), 20., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95), (0., 0.95)]), 20., 10.),
Item(Polygon([(0., 0.), (1.5, 0.), (1.5, 0.95), (0., 0.95)]), 20., 10.),
Item(Polygon([(0., 0.), (0.8, 0.), (0.8, 0.45), (0., 0.45)]), 20., 30.),
Item(Polygon([(0., 0.), (0.8, 0.), (0.8, 0.45), (0., 0.45)]), 20., 30.),
Item(Polygon([(0., 0.), (0.8, 0.), (0.8, 0.1), (0., 0.1)]), 5., 25.),
Item(Polygon([(0., 0.), (0.8, 0.), (0.8, 0.1), (0., 0.1)]), 5., 25.)]
problem = Problem(container, items)
problems.append(problem)
solution = Solution(problem)
solutions.append(solution)
print_if_allowed(solution.add_item(0, (4.23, 2.48), 0.), can_print)
print_if_allowed(solution.add_item(1, (4.23, 2.52), 180.), can_print)
print_if_allowed(solution.add_item(2, (0.77, 2.48), 0.), can_print)
print_if_allowed(solution.add_item(3, (0.77, 2.52), 180.), can_print)
print_if_allowed(solution.add_item(4, (2.48, 0.76), 270.), can_print)
print_if_allowed(solution.add_item(5, (2.52, 0.76), 90.), can_print)
print_if_allowed(solution.add_item(6, (2.48, 4.24), 270.), can_print)
print_if_allowed(solution.add_item(7, (2.52, 4.24), 90.), can_print)
print_if_allowed(solution.add_item(8, (2.5, 2.48), 0.), can_print)
print_if_allowed(solution.add_item(9, (2.5, 2.52), 180.), can_print)
print_if_allowed(solution.add_item(16, (2.5, 3.25), 0.), can_print)
print_if_allowed(solution.add_item(17, (2.5, 1.75), 0.), can_print)
print_if_allowed(solution.add_item(18, (1.64, 2.5), 90.), can_print)
print_if_allowed(solution.add_item(19, (3.36, 2.5), 90.), can_print)
# show elapsed time
elapsed_time = get_time_since(start_time)
print_if_allowed("Manual elapsed time: {} ms".format(round(elapsed_time, 3)), can_print)
return problems, [str(i + 1) for i in range(len(problems))], solutions
class Cluster:
def __init__(self, cells={}, min_ellipse_axis=1):
"""
Constructor
@param cells: set of (i,j) tuples
@param min_ellipse_axis: minimum axis length used in isCentreInsideOfExt
"""
# set of i,j cells
self.cells = cells
# want the ellipse axes to scale to at least this area
self.min_ellipse_axis = min_ellipse_axis
# ellipse representing the "average" distribution
# of cells
self.ellipse = None
# min/max indices of the box containing the set of points
self.box = [[None, None], [None, None]]
# compute the ellipse...
self.update()
def getNumberOfCells(self):
"""
Get the number of cells
@return number
"""
return len(self.cells)
def update(self):
if len(self.cells) > 0:
self.ellipse = Ellipse(self.cells,
min_ellipse_axis=self.min_ellipse_axis)
for dim in range(0, 2):
self.box[0][dim] = numpy.min([c[dim] for c in self.cells])
self.box[1][dim] = numpy.max([c[dim] for c in self.cells])
def isCentreInsideOf(self, otherCluster):
"""
Check if this ellipse' centre is inside the other cluster's ellipse
@param otherCluster: other cluster
@return True if inside
"""
return otherCluster.ellipse.isPointInside(self.ellipse.getCentre())
def isCentreInsideOfExt(self, otherCluster):
"""
Check if this ellipse' centre is inside the other cluster's extended ellipse
@param otherCluster: other cluster
@return True if inside
"""
return otherCluster.ellipse.isPointInsideExt(self.ellipse.getCentre())
def isClusterInsideOf(self, otherCluster, frac=0.99):
"""
Check if fraction of this cluster is inside other cluster
@param otherCluster: other cluster
@param frac: fraction of min area of self
@return True if at least frac is inside
"""
min_area = min(len(self.cells), len(otherCluster.cells))
return len(self.cells.intersection(
otherCluster.cells)) >= frac * min_area
def getCentre(self):
"""
Get the centre
@return array
"""
return self.ellipse.getCentre()
def getDistance(self, otherCluster):
"""
Get the distance between the two clusters' centres
@param otherCluster
@return distance
"""
d = self.ellipse.getCentre() - otherCluster.ellipse.getCentre()
return numpy.sqrt(d.dot(d))
def __mul__(self, otherCluster):
"""
Overload of * operator, returns a cluster that is the intersection of
this and otherCluster
@param otherCluster
@return intersection of self with otherCluster
"""
return Cluster(self.cells.intersection(otherCluster.cells))
def __iadd__(self, otherCluster):
"""
Overload of += operator, add othercluster cells to self
@param otherCluster: other cluster
"""
self.cells = self.cells.union(otherCluster.cells)
self.update()
return self
def writeFile(self, filename):
"""
Write to netcdf file
@param filename: file name
"""
import netCDF4
iCoords, jCoords, ijValues = self.toArray()
nc = netCDF4.Dataset(filename, 'w', format="NETCDF4")
iDim = nc.createDimension('iDim', size=iCoords.shape[0])
jDim = nc.createDimension('jDim', size=jCoords.shape[0])
iVar = nc.createVariable('i', 'i4', dimensions=('iDim', ))
jVar = nc.createVariable('j', 'i4', dimensions=('jDim', ))
nbVar = nc.createVariable('nb', 'i4', dimensions=('iDim', 'jDim'))
iVar[:] = iCoords
jVar[:] = jCoords
nbVar[:, :] = ijValues
nc.close()
def toArray(self, bounds=[]):
"""
Convert this cluster to numpy (dense) array
@param bounds: [[iMin, jMin], [iMax, jMax]]
@return array of coordinates, array of zeros and ones
"""
if len(self.cells) <= 0:
return numpy.array([]), numpy.array([]), numpy.array([])
if not bounds:
bounds = self.box
iCoords = numpy.arange(bounds[0][0], bounds[1][0] + 1)
jCoords = numpy.arange(bounds[0][1], bounds[1][1] + 1)
ijValues = numpy.zeros((len(iCoords), len(jCoords)), numpy.int32)
iMin, jMin = bounds[0]
for c in self.cells:
ijValues[c[0] - iMin, c[1] - jMin] = 1
return iCoords, jCoords, ijValues
def __repr__(self):
"""
Print object
"""
res = """
Cluster: num cells = {} box = {} ellipse centre = {} a = {} b = {} transf = {} angle = {}
""".format(len(self.cells), self.box, \
self.ellipse.centre, self.ellipse.a, self.ellipse.b, \
self.ellipse.ij2AxesTransf, self.ellipse.angle)
return res
area = round(((magnifiedArea * rect.getArea())/n), 4)
return area
def getAreaOfOverlap(e1, e2):
"""
Calculates a rectangle that embeds both the Ellipse and calls the computeAreaOfOverlap method to calculate the area of overlap between two Ellipse passed as parametersself.
Parameters:
e1 (Ellipse): First instance of Ellipse class
e2 (Ellipse): Second instance of Ellipse class
Returns:
area (float): Area of overlap between two Ellipse.
"""
rect = getRectangle(e1, e2)
area = computeAreaOfOverlap(e1, e2, rect)
return area
if __name__ == '__main__':
eclipse1FocalPoint1 = Point(-2.236, 0)
eclipse1FocalPoint2 = Point(2.236, 0)
e1 = Ellipse(eclipse1FocalPoint1, eclipse1FocalPoint2, 6)
eclipse2FocalPoint1 = Point(-1.8284, -0.5)
eclipse2FocalPoint2 = Point(3.8284, -0.5)
e2 = Ellipse(eclipse2FocalPoint1, eclipse2FocalPoint2, 6)
print(e1)
print(e2)
print("Area of overlap = {}".format(getAreaOfOverlap(e1, e2)))
def _estimate(cls, ellipse_cand):
"""Estimate ellipse parameters
Args:
ellipse_cand: A EllipseCandidate instance.
Returns:
A Ellipse instance.
"""
seg_i, seg_j, cij, ra_ij, rb_ij, sa_ij, sb_ij = ellipse_cand.seg_pair_ij.all_params
seg_k, _, cki, ra_ki, rb_ki, sa_ki, sb_ki = ellipse_cand.seg_pair_ki.all_params
# Estimate ellipse center
xc = (cij[0] + cki[0]) / 2
yc = (cij[1] + cki[1]) / 2
# Estimate ellipse angle (rho) and N (ratio of major and minor axis
q_values = [
[ra_ij, sa_ij, ra_ki, sa_ki],
[ra_ij, sa_ij, rb_ki, sb_ki],
[rb_ij, sb_ij, rb_ki, sb_ki],
[rb_ij, sb_ij, ra_ki, sa_ki],
]
# Estimate N and rho(angle of ellipse).
n_acc = [0] * cls.NUM_BIN_N_ACCUMULATOR # N \in [0, 1]
rho_acc = [0] * cls.NUM_BIN_RHO_ACCUMULATOR # \rho \in [-\pi/2, \pi/2]
for i in range(4):
q1, q2_list, q3, q4_list = q_values[i]
for q2 in q2_list:
for q4 in q4_list:
alpha = q1 * q2 - q3 * q4
beta = (q3 * q4 + 1) * (q1 + q2) - (q1 * q2 + 1) * (q3 + q4)
k_plus = (-beta + math.sqrt(beta ** 2 + 4 * alpha ** 2)) / (2 * alpha)
try:
v = ((q1 - k_plus) * (q2 - k_plus) / ((1 + q1 * k_plus) * (1 + q2 * k_plus)))
n_plus = math.sqrt(-v)
except ValueError:
print('ValueError exception')
continue # TODO: Avoid plus v value. Is avoiding ValueError wrong process?
if n_plus <= 1:
n = n_plus
else:
n = 1.0 / n_plus
if n_plus <= 1:
rho = math.atan(k_plus)
else:
rho = math.atan(k_plus) + math.pi / 2
if rho > math.pi / 2:
rho -= math.pi
rho_bin = int((rho + math.pi / 2) / math.pi * (cls.NUM_BIN_RHO_ACCUMULATOR - 1))
n_bin = int(n * (cls.NUM_BIN_N_ACCUMULATOR - 1))
n_acc[n_bin] += 1
rho_acc[rho_bin] += 1
n = np.argmax(n_acc) / (cls.NUM_BIN_N_ACCUMULATOR - 1.0)
rho = np.argmax(rho_acc) / (cls.NUM_BIN_RHO_ACCUMULATOR - 1.0) * math.pi - math.pi / 2 # Ellipse angle
k = math.tan(rho)
a_acc = [0] * (cls.MAX_MAJOR_SEMI_AXIS_LEN + 1)
for xi, yi in np.r_[seg_i.points, seg_j.points, seg_k.points]:
x0 = ((xi - xc) + (yi - yc) * k) / math.sqrt(k ** 2 + 1)
y0 = (-(xi - xc) * k + (yi - yc)) / math.sqrt(k ** 2 + 1)
ax = math.sqrt((x0 ** 2 * n ** 2 + y0 ** 2) / (n ** 2 * (k ** 2 + 1)))
a = ax / math.cos(rho)
a_acc[int(a)] += 1
a = np.argmax(a_acc) # Major semi-axis length
b = a * n # Minor semi-axis length
# Compute accuracy score
ellipse = Ellipse(center=np.array([xc, yc], dtype=np.float32), major_len=a, minor_len=b, angle=rho)
accuracy_score = (ellipse.count_lying_points(seg_i) + ellipse.count_lying_points(seg_j) + ellipse.count_lying_points(seg_k)) / float(seg_i.points.shape[0] + seg_j.points.shape[0] + seg_k.points.shape[0])
ellipse.accuracy_score = accuracy_score
return ellipse
class RRStarAlgo:
def __init__(self, init_position, final_position, safety_coeff: float = 2):
self._init_position = init_position
self._final_position = final_position
self._safety_coeff = safety_coeff
self._tree = Node(init_position)
self._nodes = [self._tree]
self._outside_nodes = []
self._obstacles = [
Obstacle(randint(10, 30), [
randint(50, CANVAS_SIZE[0] - 50),
randint(50, CANVAS_SIZE[1] - 50)
]) for _ in range(40)
]
self._arrival = None
self._ellipse = None
self._counter = 0
self._ellipse_cost_limit = inf
def step(self):
new_node = self.create_random_node()
if not self.is_valid_node(new_node):
return
best_node, near_nodes = self.choose_parent(new_node)
if not best_node:
return
self.insert_node(best_node, new_node)
if not near_nodes == []:
near_nodes.remove(best_node)
self.rewire(near_nodes, new_node)
if self.is_final_node(new_node):
self.update_arrival_node(new_node)
if self._arrival:
if self._ellipse:
if self._arrival.get_cost() < self._ellipse_cost_limit * 0.9:
self.update_ellipse()
else:
self.update_ellipse()
def choose_parent(self, new_node):
best_node = None
near_nodes = self.find_near(new_node, 50)
best_cost = None
for node in near_nodes:
cost = node.get_cost() + Node.nodes_distance(node, new_node)
if (best_cost is None) or (cost < best_cost):
if self.does_line_intersect(new_node.get_position(),
node.get_position()):
continue
best_cost = cost
best_node = node
if not best_node:
nearest_node = self.find_nearest(new_node)
if not self.does_line_intersect(nearest_node.get_position(),
new_node.get_position()):
best_node = nearest_node
return best_node, near_nodes
def insert_node(self, best_node, new_node):
new_node.set_cost(best_node.get_cost() +
Node.nodes_distance(best_node, new_node))
best_node.add_node(new_node)
self._nodes.append(new_node)
def rewire(self, near_nodes, new_node):
if near_nodes:
new_code_cost = new_node.get_cost()
for node in near_nodes:
if node.get_cost() > (new_code_cost +
Node.nodes_distance(node, new_node)):
if self.does_line_intersect(new_node.get_position(),
node.get_position()):
continue
node.set_cost(new_code_cost +
Node.nodes_distance(node, new_node))
node.reconnect(new_node)
def does_line_intersect(self, start_position, end_position):
for obstacle in self._obstacles:
if obstacle.does_line_intersect(start_position, end_position):
return True
return False
def print_tree(self, canvas: Canvas):
self._tree.print(canvas)
def print_obstacles(self, canvas: Canvas):
for obstacle in self._obstacles:
obstacle.print(canvas)
def print_arrival(self, canvas: Canvas):
if self._arrival:
position = self._final_position
canvas.create_oval(position[0] - ARRIVAL_RADIUS,
position[1] - ARRIVAL_RADIUS,
position[0] + ARRIVAL_RADIUS,
position[1] + ARRIVAL_RADIUS,
fill="blue")
def print_solution(self, canvas: Canvas):
if self._arrival:
self._arrival.print_path_to_root(canvas)
def find_nearest(self, node: Node):
return min(self._nodes, key=lambda x: Node.nodes_distance(x, node))
def find_near(self, node: Node, radius):
return list(
filter(lambda x: Node.nodes_distance(x, node) < radius,
self._nodes))
def is_valid_node(self, new_node: Node):
for obstacle in self._obstacles:
if obstacle.is_point_in(new_node, self._safety_coeff):
return False
if self._ellipse:
if not self._ellipse.is_point_in(new_node.get_position()):
return False
return True
def is_final_node(self, node: Node):
position = node.get_position()
return (((position[0] - self._final_position[0])**2 +
(position[1] - self._final_position[1])**2) <
(ARRIVAL_RADIUS**2))
def update_arrival_node(self, node: Node):
if self._arrival:
if self._arrival.get_cost() > node.get_cost():
self._arrival = node
else:
self._arrival = node
def create_random_node(self):
if self._ellipse:
return Node(self._ellipse.random_point_in())
else:
return Node(
[randint(0, CANVAS_SIZE[0]),
randint(0, CANVAS_SIZE[1])])
def update_ellipse(self):
self._ellipse = Ellipse(self._init_position, self._final_position,
self._arrival.get_cost() / 2)
self._ellipse_cost_limit = self._arrival.get_cost()
self._outside_nodes = self._outside_nodes + list(
filter(
lambda node: False == self._ellipse.is_point_in(
node.get_position()), self._nodes))
for node in self._outside_nodes:
node.set_outside_state(True)
self._nodes = list(
filter(lambda node: self._ellipse.is_point_in(node.get_position()),
self._nodes))
# Connected Components Labelling
labelNum, label, stat, centroid = cv.connectedComponentsWithStats(edges, 8)
# Discard small connected components
filteredLabelNum = filterLabelNum(stat, labelNum, args.blob_area)
logging.info(f'Blob Area : {args.blob_area}')
# Compute CCL image
ccl = computeCCL(filteredLabelNum, label)
################## RANSAC PROGRAM ##################
i = 1 # Counter
# Run RANSAC on each connected component
for labelNum in filteredLabelNum :
logging.debug(f'COMPONENT : {i}')
# Compiling the coordinates of the pixels in the contour into data points
dataPoints = compileDataPoints(label, labelNum)
# Initialize an ellispe class
ellipse = Ellipse()
# Run RANSAC on the data points
model = RANSAC(
ellipse,
dataPoints,
args.sample_size,
args.iteration,
args.threshold,
args.tolerance
)
# Draw ellipse
if (model != []) :
drawEllipse(out, model, args.crop)
logging.info(f'Component {i} process complete.')
i = i + 1
def __init__(self, fire):
self.asteroid = OBJ("asteroid.obj", textureFile="asteroid.jpg")
self.ellipse = Ellipse(18, 4, 0.17)
self.fire = fire
self.angle = 0