def main():
print("Python module")
#############################
## Pure C++ object wrapped
c1 = shapes.Circle()
c = shapes.Circle()
print(c.X) # Prints 0
print(c.R) # prints 1
print(c.V) # prints None
c.X = 1234 # changes value
print(c.X) # Prints 1234
#############################
## Totaly dynamic C++ object wrapped
o = shapes.Object()
o.X = 456 #
print(o.X) # Prints 1234
## NEED a better way to add symbols and avoid duplicates
s = shapes.Symbol("Gromit")
s = shapes.Symbol("Gromit")
s = shapes.Symbol("Gromit")
o.Gromit = 12
o.Gromit = 13
o.Gromit = 14
print(o.Gromit)
def fit_circle(points):
"""
fits a circle to the given points. The method has been adapted from
http://wiki.scipy.org/Cookbook/Least_Squares_Circle
The function returns an instance of Circle
"""
def calc_dist(xc, yc):
""" calculate the distance of each point from the center (xc, yc) """
return np.linalg.norm(points - np.array([[xc, yc]]), axis=0)
def circle_implicit(beta, x):
""" implicit definition of the circle """
return (x[0] - beta[0])**2 + (x[1] - beta[1])**2 - beta[2]**2
# coordinates of the bary center
x_m, y_m = np.mean(points, axis=0)
# initial guess for parameters
R_m = calc_dist(x_m, y_m).mean()
beta0 = [x_m, y_m, R_m]
# for implicit function :
# data.x contains both coordinates of the points (data.x = [x, y])
# data.y is the dimensionality of the response
lsc_data = odr.Data(points.T, y=1)
lsc_model = odr.Model(circle_implicit, implicit=True)
lsc_odr = odr.ODR(lsc_data, lsc_model, beta0)
lsc_out = lsc_odr.run()
# collect result
xc, yc, R = lsc_out.beta
return shapes.Circle(xc, yc, R)
def place_random_creature(environment):
if False:
environment.queue_creature(create_master_creature())
else:
r_pos = gen.random_pos(width, height, creature_radius)
name = str(r.randint(0, 1000000))
name = "0" * (4 - len(name)) + name
body = gen.Body(start_mass, shapes.Circle(r_pos, creature_radius))
brain = gen.Brain()
legs = gen.Legs()
mouth = gen.Mouth(3, 0)
fission = gen.Fission(mutation_model, init_mutation_model)
creature = gen.Creature(body, name)
creature.add_organ(brain)
creature.add_organ(legs)
creature.add_organ(mouth)
creature.add_organ(fission)
for organ in creature.organs:
organ.mutate(init_mutation_model)
r_pos = gen.random_pos(width, height, creature_radius)
creature.pos = [r_pos[0], r_pos[1]]
environment.queue_creature(creature)
def __init__(self):
super(App, self).__init__(caption="Quadtrees", width=512, height=512)
self.set_mouse_visible(False)
self.set_location(0, 900 - self.height)
self.keys = pyglet.window.key.KeyStateHandler()
self.push_handlers(self.keys)
self.paused = True
self.operation = None
self.terrain = terrain.TerrainTree(0, 0, 512, max_level=5)
self.player = obj.GameObject(self.terrain.root.rect.width // 2,
self.terrain.root.rect.height // 2)
self.brush = shapes.Circle(0, 0, 128)
self.brush_type = 1
self.highlight = collections.deque()
self.highlight_cursor = None
self.render_mode = 0
self.debug_label = pyglet.text.Label(text='LABEL',
font_size=18,
x=self.width - 20,
y=self.height - 20,
anchor_x='right',
anchor_y='top',
color=(255, 255, 255, 255))
self.play()
self.fps_display = pyglet.clock.ClockDisplay()
def __init__(self):
gtk.DrawingArea.__init__(self)
self.__checkerBoard = graphics.getCheckerPattern(16)
self.shapes = []
vPoly = shapes.Polygon([
shapes.Point(10, 10),
shapes.Point(10, 86),
shapes.Point(40, 86),
shapes.Point(86, 10),
])
iPoly = shapes.Polygon([
shapes.Point(106, 10),
shapes.Point(96, 86),
shapes.Point(140, 86),
shapes.Point(120, 50),
shapes.Point(160, 10),
])
circle = shapes.Circle(35)
circle.setCenter(shapes.Point(200, 48))
self.shapes.append(vPoly)
self.shapes.append(iPoly)
self.shapes.append(circle)
self.set_size_request(256, 96)
def chair_constructor(side, leg_side, name):
"""Footprint of a four legged classic chair"""
leg1 = shapes.Circle(leg_side)
leg1.color("r")
leg2 = shapes.Circle(leg_side)
leg2.traslate(side, 0)
leg2.color("r")
leg3 = shapes.Circle(leg_side)
leg3.traslate(side, side)
leg3.color("k")
leg4 = shapes.Circle(leg_side)
leg4.traslate(0, side)
leg4.color("r")
legs = [leg1, leg2, leg3, leg4]
chair = shapes.CompoundShape(legs, name)
return chair
def mount_sensor(self, name: str, beam: float, range: float, accuracy: float, mnt_pt: Point, mnt_orient: float):
"""Base behaviour is to update safe-radius of the vehicle taking into
account sensor accuracy
"""
if accuracy > self.max_sensor_accuracy:
self.max_sensor_accuracy = accuracy
self.safe_radius = self.shape.outer_radius() + self.max_sensor_accuracy
# Update safe region shape
self.safe_region = shapes.Circle(self.safe_radius, res=1)
def create_god(self):
from components import component
god_id = self.create_entity()
self.create_component(god_id, component.God)
self.create_component(god_id, component.Position)
self.create_component(
god_id, component.Render,
shapes.Circle(color=pygame.color.THECOLORS['darkred'], radius=20))
return god_id
def __init__(self, controller, maxX, maxY):
ShapeTool.__init__(self, controller, maxX, maxY)
self.__drawing = False
self.__circle = shapes.Circle(
int(self.getController().mapTileSize() / 2),
int(self.getController().mapTileSize() / 2))
self.setSnapInterval(int(self.getController().mapTileSize() / 2))
# A good default value, since the radius can't be negative
self.__oldRadius = -1
self.setInstructions("Click to set the center point. Click" +
" again to set the radius")
def create_bot(self, position, radius=15):
from components import component
bot_id = self.create_entity()
self.create_component(bot_id, component.Brain)
self.create_component(bot_id, component.Position, position=position)
self.create_component(bot_id, component.Render,
shapes.Circle(color=colors.red, radius=radius))
self.create_component(bot_id, component.Boundary, radius=radius)
self.create_component(bot_id, component.Vision, radius=(radius * 8))
self.create_component(bot_id, component.Log, bot_id)
return bot_id
def mouseButtonPress(self, button, time):
if self.__drawing:
controller = self.getController()
action = undo.ShapeAddAction(controller, self.__circle)
controller.addUndoAction(action)
controller.addShape(self.__circle)
self.__circle = shapes.Circle(int(controller.mapTileSize() / 2),
int(controller.mapTileSize() / 2))
self.__drawing = False
else:
if button == 1:
self.__circle.setCenter(shapes.Point(self.x(), self.y()))
self.__drawing = True
def __init__(self, name: str, chassis_shape: ChassisShape):
"""
Defines dimensions and graphical aspect of the vehicle
Parameters
----------
name : str
name of the vehicle
color : str
color string as allowed by matplotlib's plot method
"""
# Position defaults to the origin of the reference system
self.position = Point(0, 0)
# Orientation is taken from the x (horizontal) axis and is stored
# in radian
self.orientation = 0 # rad
# Vehicle path.
# List of vehicle position and orientation after every movement
self.path = []
self.seq_counter = 0
# Dimensions
self.length = 0.0
self.width = 0.0
self.color = "r"
# Vehicle name will be shown at vehicle position
self.name = name
# Vehicle Shape.
self.shape = chassis_shape
# Calculate safe region with a margin
self.safe_radius = chassis_shape.outer_radius()
# Safe region shape
self.safe_region = shapes.Circle(self.safe_radius, res=1)
# Sensor list as dictionay; this way you can read sensor by name
self.sensors = dict()
self.max_sensor_accuracy = 0
# Flatland Environment
self.flatland = None
# Tracing flag
self.tracing = False
def testGrad():
N = 50
rad = constants.R_inner
L = 4 * rad + 2
shapecoll = shapes.ShapeCollection()
circ1 = shapes.Circle((0.5, 0), rad)
circ2 = shapes.Circle((-0.5, 0), rad)
shapecoll.addShape(circ1)
shapecoll.addShape(circ2)
circ_ls = level_set.LevelSet(N, N, L, L, shapecoll)
SDF = circ_ls.getSDF()
circ_ls.reinitialize()
grad1 = circ_ls.computeGrad(level_set.GradientMode.UPWIND_FIRST)
# grad2 = circ_ls.computeGrad(level_set.GradientMode.UPWIND_SECOND)
for i in range(100):
circ_ls.advance(1)
grad = circ_ls.computeGrad()
print(np.max(grad[circ_ls.getInsidePoints()]))
# circ_ls.make_plot(thing_to_plot = grad)
grad_final = circ_ls.computeGrad()
circ_ls.make_plot(thing_to_plot=grad_final)
circ_ls.make_plot()
plt.show()
#
# axes[0].set(aspect='equal')
# axes[1].set(aspect='equal')
# axes[2].set(aspect='equal')
plt.show()
def create_master_creature():
name = "Genesis"
body = gen.Body(start_mass, shapes.Circle((100, 100), creature_radius))
body.rotation = 90
brain = gen.Brain()
legs = gen.Legs()
mouth = gen.Mouth(1, 0, 10, 1)
fission = gen.Fission(mutation_model)
eye_left = gen.EuclideanEye(10, 40, 6)
eye_right = gen.EuclideanEye(10, -40, 6)
creature = gen.Creature(body, name)
creature.add_organ(brain)
creature.add_organ(legs)
creature.add_organ(mouth)
creature.add_organ(fission)
creature.add_organ(eye_left)
creature.add_organ(eye_right)
fission_hn = brain.hidden_layer[1]
body.age_neuron.connect_to_neuron(fission_hn, 1)
body.mass_neuron.connect_to_neuron(fission_hn, 1)
fission_hn.connect_to_neuron(fission.fission_neuron, 1)
eye_left_hn = brain.hidden_layer[2]
eye_left.vision_neuron.connect_to_neuron(eye_left_hn, 1)
eye_left_hn.connect_to_neuron(legs.turn_clockwise_neuron, 1)
eye_right_hn = brain.hidden_layer[3]
eye_right.vision_neuron.connect_to_neuron(eye_right_hn, 1)
eye_right_hn.connect_to_neuron(legs.turn_clockwise_neuron, -1)
has_eaten_hn = brain.hidden_layer[4]
mouth.has_eaten_neuron.connect_to_neuron(has_eaten_hn, 1)
has_eaten_hn.connect_to_neuron(legs.forward_neuron, -0.9)
has_eaten_hn.connect_to_neuron(mouth.eat_neuron, 2)
distance_moved_hn = brain.hidden_layer[5]
legs.distance_moved_neuron.connect_to_neuron(distance_moved_hn, 1)
brain.bias_input_layer.connect_to_neuron(distance_moved_hn, -1)
distance_moved_hn.connect_to_neuron(legs.turn_clockwise_neuron, 1)
brain.bias_hidden_layer.connect_to_neuron(fission.fission_neuron, -0.7)
brain.bias_hidden_layer.connect_to_neuron(legs.forward_neuron, 1)
brain.bias_hidden_layer.connect_to_neuron(mouth.eat_neuron, 0.1)
r_pos = gen.random_pos(width, height, creature_radius)
creature.pos = [r_pos[0], r_pos[1]]
return creature
def computeCircVals(num, show_plot=False):
# make circle
shapecoll = shapes.ShapeCollection()
circ = shapes.Circle((1, 1), rad)
shapecoll.addShape(circ)
circ_ls = level_set.LevelSet(num, num, L, L, shapecoll)
if show_plot:
circ_ls.make_plot()
circ_area = circ_ls.computeArea()
circ_perim = circ_ls.computePerim()
gradNorm = circ_ls.computeUpwindGrad()
return circ_area, circ_perim
def __parseCircle(self, circle):
c = shapes.Circle(0.0)
if "center" in circle:
c.setCenter(
shapes.Point(circle["center"]["x"], circle["center"]["y"]))
else:
log.error("Circle specified with no center")
if "radius" in circle:
c.setRadius(circle["radius"])
else:
log.error("Circle specified with no radius")
if "damage" in circle:
c.damage = circle["damage"]
if "friction" in circle:
c.friction = circle["friction"]
if "restitution" in circle:
c.restitution = circle["restitution"]
return c
def create_visualise_bounding_button():
button_area = shapes.Rectangle(0, 0, 30, 30)
button = rendering.Button(button_area)
icon_shapes = [
shapes.Circle((8, 10), 7),
shapes.LineSegment((5, 28), (28, 18))
]
for shape in icon_shapes:
if shape.has_area():
shape_graphic = rendering.SimpleMonoColouredGraphic(
shape, colours.BLUE)
else:
shape_graphic = rendering.SimpleOutlineGraphic(shape, colours.BLUE)
button.add_canvas(shape_graphic)
button.add_canvas(
rendering.SimpleOutlineGraphic(shape.to_bounding_rectangle(),
colours.RED))
return button
def load_from_file(self):
"""Загрузить распределение из файла."""
try:
loaded_file, _ = QtWidgets.QFileDialog.getOpenFileName(
None, 'Введите имя файла', self.work_dir,
'Файлы распределений частиц (*.tsv)')
self.loaded_files.append(loaded_file)
import shapes
with open(loaded_file, 'r') as f:
loaded = []
for strings_list in csv.reader(f, delimiter='\t'):
numbers_list = []
for string in strings_list:
numbers_list.append(float(string))
loaded.append(tuple(numbers_list))
# определение размерности задачи
for i in loaded:
if i[2]: # хотя бы один параметр z != 0
self.options['dim_ind'] = 1
break
for i in loaded:
if self.options['dim_ind'] == 0: # 2D
self.loaded_particles.append(
shapes.Circle(x=i[0], y=i[1], d=i[3]))
elif self.options['dim_ind'] == 1: # 3D
self.loaded_particles.append(
shapes.Sphere(x=i[0], y=i[1], z=i[2], d=i[3]))
self.message('Загружен файл: {0}'.format(loaded_file))
self.all_particles.extend(self.loaded_particles)
self.cleanDistributions.setEnabled(True)
except FileNotFoundError:
self.message(
'Распределение не загружено!\nПричина: не введено имя файла')
def calc_regular_distribution(self):
"""Calculation regular distribution."""
import shapes
self.regular_particles = [] # очистка
x0 = self.options['regular_distribution'][0][0]
dx = self.options['regular_distribution'][1][0]
nx = self.options['regular_distribution'][2][0]
y0 = self.options['regular_distribution'][0][1]
dy = self.options['regular_distribution'][1][1]
ny = self.options['regular_distribution'][2][1]
if self.options['dim_ind'] == 1: # 3D
z0 = self.options['regular_distribution'][0][2]
dz = self.options['regular_distribution'][1][2]
nz = self.options['regular_distribution'][2][2]
for x in [x0 + dx * i for i in range(nx)]:
for y in [y0 + dy * i for i in range(ny)]:
if self.options['dim_ind'] == 1: # 3D
for z in [z0 + dz * i for i in range(nz)]:
particle = shapes.Sphere(
x, y, z,
self.options['regular_distribution_diameter'])
self.regular_particles.append(particle)
else: # 2D
# z = 0
particle = shapes.Circle(
x, y, self.options['regular_distribution_diameter'])
self.regular_particles.append(particle)
self.all_particles.extend(
self.regular_particles) # расширить список всех частиц
self.button_save.setEnabled(True)
self.clean_distributions.setEnabled(True)
self.message('Регулярное распределение частиц посчитано')
def readShapesFromJson(data):
shapes_list = []
if 'Figures' not in data.keys():
return []
palette = data['Palette']
i = 1
for shape in data['Figures']:
if (validate.validateShape(shape)):
color = ''
if 'color' in shape:
if validate.validateColor(shape['color'], palette):
color = shape['color']
if shape['type'] == 'point':
shapes_list.append(shapes.Point(shape['x'], shape['y']))
elif shape['type'] == 'polygon':
points = []
for point in shape['points']:
points.append(shapes.Point(point[0], point[1]))
shapes_list.append(shapes.Polygon(points, color))
elif shape['type'] == 'rectangle':
point = shapes.Point(shape['x'], shape['y'])
rect = shapes.Rectangle(point, shape['width'], shape['height'],
color)
shapes_list.append(rect)
elif shape['type'] == 'square':
point = shapes.Point(shape['x'], shape['y'])
shapes_list.append(
shapes.Square(point, shape.get('size'), color))
elif shape['type'] == 'circle':
point = shapes.Point(shape['x'], shape['y'])
shapes_list.append(
shapes.Circle(point, shape.get('radius'), color))
else:
print('Wrong type in Figure number', i, 'in file.')
else:
print('Wrong parameters in Figure number', i, 'in file.')
i = i + 1
return shapes_list
def main():
bates_srm = BatesSRM()
shapecoll = shapes.ShapeCollection()
circ = shapes.Circle((0, 0), R_inner)
shapecoll.addShape(circ)
bates_grain_ls = LevelSetSRM(shapecoll)
theta = np.arange(0, 4) * np.pi / 4.
lines_c = []
lines = [
shapes.LineSegment(
[finocyl_spoke_len * np.cos(t), finocyl_spoke_len * np.sin(t)],
[-finocyl_spoke_len * np.cos(t), -finocyl_spoke_len * np.sin(t)],
width=finocyl_spoke_width) for t in theta
]
[shapecoll.addShape(l) for l in lines]
finocyl_grain_ls = LevelSetSRM(shapecoll)
sustainer_assembly = SRM_Assembly({bates_grain_ls: 5})
booster_assembly = SRM_Assembly({finocyl_grain_ls: 2, bates_grain_ls: 5})
Pb, Tb, Ab, xb, tb = runAndTimeSRM(booster_assembly, "Booster", True)
np.savetxt("results/Pb.txt", Pb)
np.savetxt("results/Tb.txt", Tb)
np.savetxt("results/Ab.txt", Ab)
np.savetxt("results/xb.txt", xb)
Psus, Tsus, Asus, xsus, tsus = runAndTimeSRM(sustainer_assembly,
"Sustainer", True)
np.savetxt("results/Psus.txt", Psus)
np.savetxt("results/Tsus.txt", Tsus)
np.savetxt("results/Asus.txt", Asus)
np.savetxt("results/xsus.txt", xsus)
#!/usr/bin/python3
import shapes
square1 = shapes.Square(3.0)
circle1 = shapes.Circle(4.0)
print("length of square1 = " + str(square1.getSide()))
print("radius of circle1 = " + str(circle1.getRadius()))
class View2D:
"""View2D."""
def __init__(self, edge, data):
plt.close('all')
plt.figure(num='Микроструктура', figsize=(7, 7), dpi=100)
ax = plt.axes()
FrontView(axes=ax, data=data, matrix_edge=edge)
plt.tight_layout()
plt.show()
if __name__ == '__main__':
import shapes
m = shapes.CubeMatrix(edge=100.)
p1 = shapes.Sphere(x=0., y=20., z=40., d=10.)
p2 = shapes.Sphere(x=50., y=50., z=50., d=20.)
View3D(m.edge, [p1, p2])
p3 = shapes.Circle(x=10., y=40, d=30.)
p4 = shapes.Circle(x=50., y=75., d=15.)
View2D(m.edge, [p3, p4])
def make_components(self):
shape = shapes.Circle(self.pos, self.radius, 10)
component = Component(shape, self.water_color)
self.components.append(component)
def make_components(self):
shape = shapes.Circle(self.pos, self.radius, 5, angle=math.pi)
c = Component(shape, self.hill_color)
self.components.append(c)
import shapes
import base
xy = [0, 0]
triangle = shapes.Triangle(xy, 1, 4)
circle = shapes.Circle(xy, 2)
square = shapes.Square(xy, 1)
ellipse = shapes.Ellipse(xy, 3, 2)
rectangle = shapes.Rectangle(xy, 14, 3)
mylist = [triangle, square, rectangle, circle, ellipse]
for item in mylist:
if isinstance(item, base.Polygon):
print(f"{item} located at {item.center} of size {item._size}")
else:
print(f"{item} located at {item.center} of radius {item.radius}")
def create_obstacle_circle(center, radius):
o = Obstacle(lambda r: dist(r, center) - radius,
lambda r: normalize(r - center),
shapes.Circle(center, radius))
o.center = center
return o
class Program(object):
def run(self, new_shapes):
while 1:
command = input(
"Please enter a shape (cube, triangular pyramid, circle, quadrilateral, pentagon or triangle). Type 'exit' to quit the program: "
)
for shape in new_shapes:
if command in shape.name:
shape.get_shape_ui().get_details()
print("Area/Volume: ", shape.algorithm1(),
"\nPerimeter/Surface area: ", shape.algorithm2())
elif "exit" in command:
sys.exit("Seeya!")
SHAPES = [
shapes.TwoDAdapter(shapes.Circle("circle")),
shapes.TwoDAdapter(shapes.Quadrilateral("quadrilateral")),
shapes.TwoDAdapter(shapes.Pentagon("pentagon")),
shapes.TwoDAdapter(shapes.Triangle("triangle")),
tridshapes.TriDAdapter(tridshapes.RectangularPrism('cube')),
tridshapes.TriDAdapter(tridshapes.TriPyramid('triangular pyramid'))
]
program = Program()
program.run(SHAPES)
r1.get_name()
print("side is ", end="")
r1.get_side()
print("\n")
s1 = shapes.Square()
s1.set_name()
s1.get_name()
print("side is ", end="")
s1.get_side()
print("\n")
ell1 = shapes.Ellipse()
ell1.set_name()
ell1.get_name()
ell1.set_params(40, 80)
print("Area is ", end="")
ell1.get_area()
print("\n")
c1 = shapes.Circle()
c1.set_name()
c1.get_name()
c1.set_radius(20)
print("Area is ", end="")
c1.get_area()
print("\n")
def main():
width = int(sys.argv[1])
height = int(sys.argv[2])
max_obstacles = int(sys.argv[3])
num_approx_points = int(sys.argv[4])
file_name = str(sys.argv[5])
if os.path.exists(file_name):
print(
'The map with the give name already exists. Please delete it manually before proceeding to overwrite it.'
)
boundary_offset = 10
min_length = 40
max_length = 70
obstacles_list = []
obstacles_type = []
# Dummy obstacle to prevent the starting point of seekers
# from getting blocked by some obstacle
obs = shapes.Square((30, 30), 60)
obstacles_list.append(obs)
obstacles_type.append('square')
num_obstacles = 0
while num_obstacles < max_obstacles:
obs_valid = False
while not obs_valid:
cx = random.randint(max_length + boundary_offset,
width - max_length - boundary_offset)
cy = random.randint(max_length + boundary_offset,
height - max_length - boundary_offset)
length = random.randint(min_length, max_length)
choice = random.randint(0, 1)
choice = 1
if choice == 0:
obs = shapes.Square((cx, cy), length)
obs_type = 'square'
else:
obs = shapes.Circle((cx, cy), length, num_approx_points)
obs_type = 'circle'
collision = False
for other in obstacles_list:
if obs.check_aabb_collision(other, 20):
collision = True
break
if not collision:
obstacles_list.append(obs)
obstacles_type.append(obs_type)
obs_valid = True
num_obstacles += 1
f = open(file_name, 'w+')
f.write(str(width) + ', ' + str(height) + '\n')
for obs, obs_type in zip(obstacles_list[1:], obstacles_type[1:]):
centre = obs.get_centre()
token = obs_type + ': ' + str(centre[0]) + ', ' + str(centre[1])
if obs_type == 'circle':
token += ', ' + str(
obs.get_radius()) + ',' + str(num_approx_points)
elif obs_type == 'square':
token += ', ' + str(obs.get_length())
token += '\n'
f.write(token)
