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 _distance(o1, o2): return Math.sqrt(Math.pow(o2.x - o1.x,2) + Math.pow(o2.y - o1.y, 2))
# 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