def toBut(self, but):
if but.x == 'abs':
return but.y
a = but.x - self.origin.x
b = but.y - self.origin.y
if a == 0 and b == 0:
return rnd.nextDouble() * 360;
if b < 0:
return 180*Math.asin(a / Math.sqrt(Math.pow(a,2)+Math.pow(b,2)))/Math.PI+270
else:
return 180*Math.acos(a / Math.sqrt(Math.pow(a,2)+Math.pow(b,2)))/Math.PI
def toBut(self, but):
if but.x == 'abs':
return but.y
a = but.x - self.origin.x
b = but.y - self.origin.y
if a == 0 and b == 0:
return rnd.nextDouble() * 360
if b < 0:
return 180 * Math.asin(
a / Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2))) / Math.PI + 270
else:
return 180 * Math.acos(
a / Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2))) / Math.PI
def eviteObstacles(percepts):
dist1 = dist2 = 500
taille_robot = 20
liste_obstacles = []
for p in percepts:
centre = Point()
centre.setCoord(p.getX(), p.getY())
liste_obstacles.append(centre)
# on dessine 2 droite paralleles a la direction
# qui partent des bords du robot -> d1 : y = 12 et d2 : y = -12
# Dans nouveau repere : origine = self
# rotation du repere de l'angle de direction courant
direction = self.getHeading()
angle = Math.PI * direction / 180
t = Math.tan(angle)
s = Math.sin(angle)
c = Math.cos(angle)
for p in liste_obstacles:
# centre_x, centre_y : centre de l'obstacle dans le repere
centre_x = (p.getX() + t * p.getY()) / (c + s * t)
centre_y = -p.getY() / c + t * centre_x
# savoir quelle droite prendre
if centre_x > 0:
if centre_y >= 0 and centre_y <= 2 * taille_robot:
y = centre_y - taille_robot
dist1 = min(
dist1,
-Math.sqrt(taille_robot * taille_robot - y * y) + centre_x)
elif centre_y < 0 and centre_y >= -(2 * taille_robot):
y = centre_y + taille_robot
dist2 = min(
dist2,
-Math.sqrt(taille_robot * taille_robot - y * y) + centre_x)
if min(dist1, dist2) <= 100 and abs(dist1 - dist2) > 2:
if dist1 < dist2:
direction += 100 / dist1
else:
direction -= 100 / dist2
self.setHeading(direction)
def process(input, position):
size = len(input)
output = copy.deepcopy(input)
fft = DoubleFFT_1D(size)
fft.realForward(output)
for j in range(size/2):
output[j]= Math.sqrt(Math.pow(output[2*j],2)+Math.pow(output[2*j+1],2));
return output[:len(input)/2]
def singleCS(self, vs, into, node, angle):
angle += 0.5 * Math.PI
angle %= 2.0 * Math.PI
wi, h = vs.size.width, vs.size.height
a, b = wi / 2.3, h / 2.3
x0, y0 = wi / 2.0, h / 2.0
bx, by = 1, 1
e = Math.sqrt(1 - b**2 / a**2)
r = a * Math.sqrt((1 - e**2) / (1 - e**2 * Math.cos(angle)**2))
x = r * Math.cos(angle) + x0
y = -r * Math.sin(angle) + y0
cs = vs.orthoBoxCS(into, node + "_FILLET", -100, x - bx / 2,
y - by / 2, 1, 1, bx, by)
return cs
def message(self, m):
x = float(m.getArg1()) + m.getFromX()
y = float(m.getArg2()) + m.getFromY()
d = Math.sqrt(x*x+y*y)
a = m.getAct()
if a=='Me':
return 1/(d + 1)
elif a=='RocketLauncher':
if d>200 and d<400 and mem.trouille < mem.t:
mem.trouille = mem.t
def eviteAmis(percepts): dist1 = dist2 = 500 taille_robot = 20 liste_obstacles = [] for p in percepts: centre = Point() centre.setCoord(p.getX(), p.getY()) liste_obstacles.append(centre) # on dessine 2 droite paralleles a la direction # qui partent des bords du robot -> d1 : y = 12 et d2 : y = -12 # Dans nouveau repere : origine = self # rotation du repere de l"angle de direction courant direction = self.getHeading() angle = Math.PI * direction / 180 t = Math.tan(angle) s = Math.sin(angle) c = Math.cos(angle) for p in liste_obstacles: # centre_x, centre_y : centre de l"obstacle dans le repere centre_x = ( p.getX() + t* p.getY()) / (c + s * t) centre_y = -p.getY()/c + t * centre_x # savoir quelle droite prendre if centre_x > 0: if centre_y >= 0 and centre_y <= 2*taille_robot: y = centre_y - taille_robot dist1 = min(dist1,-Math.sqrt(taille_robot*taille_robot - y*y) + centre_x) elif centre_y < 0 and centre_y >= -(2*taille_robot): y = centre_y + taille_robot dist2 = min(dist2,-Math.sqrt(taille_robot*taille_robot - y*y) + centre_x) if min(dist1, dist2) <= 100 and abs(dist1 - dist2) > 2: if dist1 < dist2: direction += 100/dist1 else: direction -= 100/dist2 self.setHeading(direction)
def message(self, m):
x = float(m.getArg1()) + m.getFromX()
y = float(m.getArg2()) + m.getFromY()
d = Math.sqrt(x * x + y * y)
a = m.getAct()
if a == 'Me':
return 1 / (d + 1)
elif a == 'RocketLauncher':
if d > 200 and d < 400 and mem.trouille < mem.t:
mem.trouille = mem.t
def arcTo(self, cx, cy, p2x, p2y): """Adds a segment from the current position to p2x, p2y by drawing part of a circle centered on 'cx,cy'""" p1x, p1y = self.nodes[-1].position2() angle1 = Math.atan2(-(p1y-cy), p1x-cx) angle2 = Math.atan2(-(p2y-cy), p2x-cx) if (angle2-angle1>Math.PI): angle2-=Math.PI*2 if (angle2-angle1<-Math.PI): angle2+=Math.PI*2 self.arc(Math.sqrt( (p1x-cx)*(p1x-cx)+(p1y-cy)*(p1y-cy)), cx,cy, angle1, angle2, join=1) return self
def longJumps(t, mindist):
for nd in t.getRoot().getSubtreeNodes():
if nd.parent is None:
continue
d = Math.sqrt(Math.pow(nd.x - nd.parent.x, 2) + Math.pow(nd.y - nd.parent.y, 2))
if d > mindist:
print nd.x, nd.y
p = array([nd.x, nd.y], 'f')
aff = t.affineTransform
aff.transform(p, 0, p, 0, 1)
cal = t.layerSet.getCalibration()
print "Off:", p[0] * cal.pixelWidth, p[1] * cal.pixelHeight, (nd.layer.getParent().indexOf(nd.layer) + 1)
def NeighborChecker(xar, yar, zar, switch):
""" Check the distance to neighbors, and count the number of neighbors below thdist. """
global thdist
neighborA = zeros('d', len(xar))
if switch:
for i in range(len(xar)):
cx = xar[i]
cy = yar[i]
cz = zar[i]
for j in range(len(xar)):
if j != i :
dist = Math.sqrt( Math.pow((cx - xar[j]), 2) + Math.pow((cy - yar[j]), 2))
if dist < thdist:
if Math.abs(cz - zar[j]) < 2:
logstr = ".... Dot%d - Dot%d too close: dist = %d" % (i, j, dist)
IJ.log(logstr)
print logstr
neighborA[i] += 1
if neighborA[i] > 0:
IJ.log("---> Dot%d rejected" % (i))
print "---> Dot", i, " rejected"
return neighborA
# test new widths -- the pixels in the image window will be updated accordingly.
from ij.gui import GenericDialog
from java.awt.event import AdjustmentListener
from java.lang import Math, System
image = WindowManager.getCurrentImage()
ip = image.getProcessor()
pixelsCopy = ip.getPixelsCopy()
pixels = ip.getPixels()
width = ip.getWidth()
height = ip.getHeight()
minWidth = int(Math.sqrt(len(pixels) / 16))
maxWidth = minWidth * 16
class Listener(AdjustmentListener):
def adjustmentValueChanged(self, event):
value = event.getSource().getValue()
rowstride = min(width, value)
for j in range(0, min(height, int(width * height / value))):
System.arraycopy(pixelsCopy, j * value, pixels, j * width,
rowstride)
image.updateAndDraw()
gd = GenericDialog("Width")
gd.addSlider("width", minWidth, maxWidth, ip.getHeight())
def distance(_node1,_node2): return Math.sqrt(((_node1.x - _node2.x) * (_node1.x - _node2.x)) + ((_node1.y - _node2.y) * (_node1.y - _node2.y)))
def createWorld(self, world):
world.setGravity(Vector2(0, 0))
k_restitution = 0.4
bd = BodyDef()
bd.position.set(0, 20)
ground = world.createBody(bd)
shape = EdgeShape()
sd = FixtureDef()
sd.shape = shape
sd.density = 0
sd.restitution = k_restitution
shape.set(Vector2(-20, -20), Vector2(-20, 20))
ground.createFixture(sd)
shape.set(Vector2(20, -20), Vector2(20, 20))
ground.createFixture(sd)
shape.set(Vector2(-20, 20), Vector2(20, 20))
ground.createFixture(sd)
shape.set(Vector2(-20, -20), Vector2(20, -20))
ground.createFixture(sd)
shape.dispose()
xf1 = Transform(Vector2(), 0.3524 * Math.PI)
xf1.setPosition(xf1.mul(Vector2(1, 0)))
vertices = [None, None, None]
vertices[0] = xf1.mul(Vector2(-1, 0))
vertices[1] = xf1.mul(Vector2(1, 0))
vertices[2] = xf1.mul(Vector2(0, 0.5))
poly1 = PolygonShape()
poly1.set(vertices)
sd1 = FixtureDef()
sd1.shape = poly1
sd1.density = 4.0
xf2 = Transform(Vector2(), -0.3524 * Math.PI)
xf2.setPosition(xf2.mul(Vector2(-1, 0)))
vertices[0] = xf2.mul(Vector2(-1, 0))
vertices[1] = xf2.mul(Vector2(1, 0))
vertices[2] = xf2.mul(Vector2(0, 0.5))
poly2 = PolygonShape()
poly2.set(vertices)
sd2 = FixtureDef()
sd2.shape = poly2
sd2.density = 2.0
bd = BodyDef()
bd.type = BodyType.DynamicBody
bd.angularDamping = 5.0
bd.linearDamping = 0.1
bd.position.set(0, 2)
bd.angle = Math.PI
bd.allowSleep = False
self.m_body = world.createBody(bd)
self.m_body.createFixture(sd1)
self.m_body.createFixture(sd2)
poly1.dispose()
poly2.dispose()
shape = PolygonShape()
shape.setAsBox(0.5, 0.5)
fd = FixtureDef()
fd.shape = shape
fd.density = 1.0
fd.friction = 0.3
for i in range(10):
bd = BodyDef()
bd.type = BodyType.DynamicBody
bd.position.set(0, 5 + 1.54 * i)
body = world.createBody(bd)
body.createFixture(fd)
gravity = 10.0
I = body.getInertia()
mass = body.getMass()
radius = Math.sqrt(2 * I / mass)
jd = FrictionJointDef()
jd.localAnchorA.set(0, 0)
jd.localAnchorB.set(0, 0)
jd.bodyA = ground
jd.bodyB = body
jd.collideConnected = True
jd.maxForce = mass * gravity
jd.maxTorque = mass * radius * gravity
world.createJoint(jd)
shape.dispose()
def distanceTo(self, p): x = self.obj.getX() - p.getX() y = self.obj.getY() - p.getY() return Math.sqrt(x*x+ y*y)
def distance(x, y):
return Math.sqrt(x * x + y * y)
def processLine3D(fgeom, segment):
lines = []
#output =[]
dRemainingDistFromLastSegment = 0
geomManager = GeometryLocator.getGeometryManager()
ncoords = fgeom.getNumVertices()
if ncoords == 0:
return
dAddedPointX = fgeom.getVertex(0).getX()
dX1 = fgeom.getVertex(0).getX()
dAddedPointY = fgeom.getVertex(0).getY()
dY1 = fgeom.getVertex(0).getY()
#dZ1 = fgeom.getVertex(0).getZ()
point = geomManager.create(
fgeom.getVertex(0).getGeometryType()
) #geom.createPoint(geom.D3, [dAddedPointX, dAddedPointY, dAddedPointZ]) ## add vertex
point.setCoordinateAt(Geometry.DIMENSIONS.X, dX1)
point.setCoordinateAt(Geometry.DIMENSIONS.Y, dY1)
#point.setCoordinateAt(Geometry.DIMENSIONS.Z,dZ1) #point = geom.createPoint(geom.D3M, dX1, dY1, dZ1) #dAddedPointX, dAddedPointY, 0)
#output.append(point)
newline = geomManager.create(
fgeom.getGeometryType()) #geom.LINE, geom.D3M)
#newline.addVertex(point)
for i in range(0,
fgeom.getNumVertices() -
1): #(i = 0; i < coords.length - 1; i++) {
dX2 = fgeom.getVertex(i + 1).getX()
dX1 = fgeom.getVertex(i).getX()
dY2 = fgeom.getVertex(i + 1).getY()
dY1 = fgeom.getVertex(i).getY()
#dZ2 = fgeom.getVertex(i+1).getZ()
#dZ1 = fgeom.getVertex(i).getZ()
dDX = dX2 - dX1
dDY = dY2 - dY1
#dDZ = dZ2 - dZ1
dDistToNextPoint = Math.sqrt(dDX * dDX + dDY * dDY)
newline.addVertex(fgeom.getVertex(i))
if dRemainingDistFromLastSegment + dDistToNextPoint > segment: ## si el segmento es mayor lo partimos
iPoints = (dRemainingDistFromLastSegment +
dDistToNextPoint) / segment
dDist = segment - dRemainingDistFromLastSegment # distancia segmento inicial lo que falta para completar el anterior
for j in range(0, int(iPoints)):
dDist = segment - dRemainingDistFromLastSegment
dDist += j * segment
dAddedPointX = dX1 + dDist * dDX / dDistToNextPoint
dAddedPointY = dY1 + dDist * dDY / dDistToNextPoint
#dAddedPointZ = dZ1 + dDist *dDZ / dDistToNextPoint
point = geomManager.create(
fgeom.getVertex(i).getGeometryType())
point.setCoordinateAt(Geometry.DIMENSIONS.X, dAddedPointX)
point.setCoordinateAt(Geometry.DIMENSIONS.Y, dAddedPointY)
#point.setCoordinateAt(Geometry.DIMENSIONS.Z,dAddedPointZ)
#output.append(point)
newline.addVertex(point)
lines.append(newline)
newline = geomManager.create(fgeom.getGeometryType())
newline.addVertex(point)
dDX = dX2 - dAddedPointX
dDY = dY2 - dAddedPointY
#newline = geomManager.create(fgeom.getGeometryType()) #newline = geom.createGeometry(geom.LINE, geom.D3)
#newline.addVertex(point)
dRemainingDistFromLastSegment = Math.sqrt(dDX * dDX + dDY * dDY)
else: # si es menor lo agregamos y pasamos al siguiente segmento
dRemainingDistFromLastSegment += dDistToNextPoint
#newline.addVertex(dX1, dY1, dZ1)
print "addvertex2"
newline.addVertex(dX2, dY2) #, dZ2)
print newline
#newline.addVertex(dX2, dY2, dZ2)
if not newline.getNumVertices() <= 1:
lines.append(newline)
else:
print "tak"
print newline.getVertex(0)
#print newline.getVertex(0)#.convertToWKT()
return lines
def distxy(self, ox, oy): return Math.sqrt(Math.pow(self.x-ox,2)+Math.pow(self.y-oy,2))
parser.add_option("-P", "--point-metric", metavar="STRING",
action="store", type="string", dest="point_metric_file",
help="""A CSV file containing points which to refine around. Each line must contains 5 floating point values:
- x, y, z
- the distance of the source where the target size is defined
- the target size at the given distance""")
parser.add_option("-p", "--project",
action="store_true", dest="project",
help="project vertices onto local surface")
parser.add_option("-n", "--allowNearNodes",
action="store_true", dest="allowNearNodes",
help="insert vertices even if this creates a small edge")
parser.add_option("-t", "--size", metavar="FLOAT", default=0.0,
action="store", type="float", dest="size",
help="target size")
parser.add_option("-T", "--nearLengthRatio", metavar="FLOAT", default=1.0 / Math.sqrt(2.0),
action="store", type="float", dest="nearLengthRatio",
help="ratio to size target to determine if a vertex is near an existing point (default: 1/sqrt(2)")
parser.add_option("-I", "--immutable-border",
action="store_true", dest="immutable_border",
help="Tag free edges as immutable")
parser.add_option("--record", metavar="PREFIX",
action="store", type="string", dest="recordFile",
help="record mesh operations in a Python file to replay this scenario")
(options, args) = parser.parse_args(args=sys.argv[1:])
if len(args) != 2:
parser.print_usage()
sys.exit(1)
def distance (x, y):
return Math.sqrt (x*x + y*y)
def __abs__(self):
return Math.sqrt(self.norm2())
def metric(self, l):
# Use Java API directly
import java.lang.Math as math
return math.sqrt(l[0] / l[1])
def dist(self, p):
return Math.sqrt(((self.y-p.y)*(self.y-p.y))+((self.x-p.x)*(self.x-p.x)))
def __abs__(self):
return Math.sqrt(self.x*self.x+self.y*self.y)
def distanceTo(self, p):
x = self.obj.getX() - p.getX()
y = self.obj.getY() - p.getY()
return Math.sqrt(x * x + y * y)
def distxy(self, ox, oy):
return Math.sqrt(Math.pow(self.x - ox, 2) + Math.pow(self.y - oy, 2))
def distance(_node1, _node2):
return Math.sqrt(((_node1.x - _node2.x) * (_node1.x - _node2.x)) +
((_node1.y - _node2.y) * (_node1.y - _node2.y)))
def distance(x, y):
try:
return Math.sqrt(x * x + y * y)
except:
return -1
def _distance(o1, o2):
return Math.sqrt(Math.pow(o2.x - o1.x, 2) + Math.pow(o2.y - o1.y, 2))
parser.add_option("--no-preserveGroups", default=True, action="store_false",
dest="preserveGroups",
help="do not preserve groups: edges adjacent to two "
"different groups are handled like normal edges (default: "
"preserve groups)")
parser.add_option("-k", "--skeleton",
default=False, action="store_true", dest="skeleton",
help="remesh skeleton beforehand")
parser.add_option("-n", "--allowNearNodes",
action="store_true", dest="allowNearNodes",
help="insert vertices even if this creates a small edge")
parser.add_option("-r", "--rho", metavar="FLOAT", default=2.0,
action="store", type="float", dest="rho",
help="numerical metric ratio (required: rho > 1, default: 2)")
parser.add_option("-T", "--nearLengthRatio", metavar="FLOAT",
default=1.0/Math.sqrt(2.0), action="store", type="float",
dest="nearLengthRatio",
help="ratio to size target to determine if a vertex is near "
"an existing point (default: 1/sqrt(2))")
parser.add_option("-w", "--wire", metavar="FLOAT", default=-1.0,
action="store", type="float", dest="wire",
help="remesh beams (default: -1.0: do not remesh)")
parser.add_option("-e", "--eratio", metavar="FLOAT", default=10.0,
action="store", type="float", dest="eratio",
help="remove triangles whose edge ratio is greater than "
"tolerance (default: 10.0)")
parser.add_option("-I", "--immutable-border",
action="store_true", dest="immutable_border",
help="Tag free edges as immutable")
parser.add_option("-M", "--immutable-groups", metavar="STRING",
action="store", type="string", dest="immutable_groups_file",
def computeWorldCorrection(): x0, y0, z0 = 43324.0, 41836.0, 0.0 x1, y1, z1 = 46780.0, 45532.0, 22950.0 x2, y2, z2 = x0, y0, z1 # A point in the first section that should be directly on top of the x0,y0,z0 x3, y3, z3 = 48164, 23372, 0 trans = Transform3D() trans.setTranslation(Vector3d(-x0, -y0, 0)) rot = Transform3D() p0 = Vector3d(0, 0, z1) p1 = Vector3d(x1 - x0, y1 - y0, z1 - z0) pc = Vector3d() pc.cross(p1, p0) angle = Math.atan(Math.sqrt(Math.pow(x1 - x0, 2) + Math.pow(y1 - y0, 2)) / (z1 - z0)) print angle * 180 / Math.PI rot.setRotation(AxisAngle4d(pc, angle)) t = Transform3D() t.mul(rot) t.mul(trans) # Transform the third point p3 = Point3d(x3, y3, z3) t.transform(p3) print "A p3:", p3 # test p0 = Point3d(x0, y0, z0) t.transform(p0) print "A: p0", p0 p1 = Point3d(x1, y1, z1) t.transform(p1) print "A: p1", p1 # Compute rotation of third point around Z axis rotZ = Transform3D() angleZ = Math.atan((p3.x - 0) / (p3.y - 0)) print "angleZ", angleZ rotZ.setRotation(AxisAngle4d(Vector3d(0,0,1), angleZ)) t.mul(rotZ, t) # test p0 = Point3d(x0, y0, z0) t.transform(p0) print p0 p1 = Point3d(x1, y1, z1) t.transform(p1) print p1 p3 = Point3d(x3, y3, z3) t.transform(p3) print p3 return t
def distance(x, y, point=[0,0]): try: return Math.sqrt((x-point[0]) * (x-point[0]) + (y-point[1]) * (y-point[1])) except: return -1
)
parser.add_option(
"-r",
"--rho",
metavar="FLOAT",
default=2.0,
action="store",
type="float",
dest="rho",
help="numerical metric ratio (required: rho > 1, default: 2)",
)
parser.add_option(
"-T",
"--nearLengthRatio",
metavar="FLOAT",
default=1.0 / Math.sqrt(2.0),
action="store",
type="float",
dest="nearLengthRatio",
help="ratio to size target to determine if a vertex is near "
"an existing point (default: 1/sqrt(2))",
)
parser.add_option(
"-w",
"--wire",
metavar="FLOAT",
default=-1.0,
action="store",
type="float",
dest="wire_size",
help="remesh beams (default: -1.0: do not remesh)",
def metric(self, l):
# Use Java API directly
import java.lang.Math as math
return math.sqrt(l[0] / l[1])
def _distance(o1, o2):
return Math.sqrt(Math.pow(o2.x - o1.x,2) + Math.pow(o2.y - o1.y, 2))
def distance(x, y): try: return Math.sqrt(x * x + y * y) except: return -1
# test new widths -- the pixels in the image window will be updated accordingly.
from ij.gui import GenericDialog
from java.awt.event import AdjustmentListener
from java.lang import Math, System
image = WindowManager.getCurrentImage()
ip = image.getProcessor()
pixelsCopy = ip.getPixelsCopy()
pixels = ip.getPixels()
width = ip.getWidth()
height = ip.getHeight()
minWidth = int(Math.sqrt(len(pixels) / 16))
maxWidth = minWidth * 16
class Listener(AdjustmentListener):
def adjustmentValueChanged(self, event):
value = event.getSource().getValue()
rowstride = min(width, value)
for j in range(0, min(height, int(width * height / value))):
System.arraycopy(pixelsCopy, j * value,
pixels, j * width, rowstride)
image.updateAndDraw()
gd = GenericDialog("Width")
gd.addSlider("width", minWidth, maxWidth, ip.getHeight())
gd.getSliders().get(0).addAdjustmentListener(Listener())
gd.showDialog()
action="store_true", dest="project",
help="project vertices onto local surface")
parser.add_option("-n", "--allowNearNodes",
action="store_true", dest="allowNearNodes",
help="insert vertices even if this creates a small edge")
parser.add_option("-t", "--size", metavar="FLOAT", default=0.0,
action="store", type="float", dest="size",
help="target size")
parser.add_option("-r", "--rho", metavar="FLOAT", default=0.0,
action="store", type="float", dest="rho",
help="numerical metric ratio (required: rho > 1)")
parser.add_option("--mixed", metavar="BOOLEAN", default=False,
action="store_true", dest="mixed",
help="""set mixed analytic-numeric metric.
rho must be set with a valid value (>1.0) using -r option, otherwise ignored.""")
parser.add_option("-T", "--nearLengthRatio", metavar="FLOAT", default=1.0 / Math.sqrt(2.0),
action="store", type="float", dest="nearLengthRatio",
help="ratio to size target to determine if a vertex is near an existing point (default: 1/sqrt(2)")
parser.add_option("-I", "--immutable-border",
action="store_true", dest="immutable_border",
help="Tag free edges as immutable")
parser.add_option("--record", metavar="PREFIX",
action="store", type="string", dest="recordFile",
help="record mesh operations in a Python file to replay this scenario")
(options, args) = parser.parse_args(args=sys.argv[1:])
if len(args) != 2:
parser.print_usage()
sys.exit(1)
def distance(x, y, point=[0, 0]):
try:
return Math.sqrt((x - point[0]) * (x - point[0]) + (y - point[1]) *
(y - point[1]))
except:
return -1
