def left(spt, ept): l_base = rs.PointAdd(spt, bh) l_height = rs.PointAdd(ept, bh) rs.AddCylinder(l_base, l_height, radius) #build columns for i in range(b_lst[3]): rs.AddCylinder(spt, l_base, b_lst[4]) spt = rs.PointAdd(spt, col_spacing) l_base = rs.PointAdd(l_base, col_spacing)
def right(spt, ept): width = [stair_width, 0, 0] r_base = rs.PointAdd(rs.PointAdd(spt, bh), width) r_height = rs.PointAdd(rs.PointAdd(ept, bh), width) rs.AddCylinder(r_base, r_height, radius) #build columns for i in range(b_lst[3]): rs.AddCylinder(rs.PointAdd(spt, width), r_base, b_lst[4]) spt = rs.PointAdd(spt, col_spacing) r_base = rs.PointAdd(r_base, col_spacing)
def __init__(self, x=0, y=0, z=0): rt.Turtle.__init__(self) self._shape = rs.AddCylinder(rg.Plane.WorldXY, 4, 1, cap=True) #self._shape =rs.GetObject("Select the runner") self.setColor(255, 0, 0) self.penUp() self.goto(x, y, z)
def right(): r_curve = rs.CopyObject(curve, [0, 0, b_lst[1]]) rs.AddPipe(r_curve, 0, b_lst[2], cap=1) rs.DeleteObjects(r_curve) pts = [rs.EvaluateCurve(curve, t) for t in ref_pts] for i in range(b_lst[3]): base = rs.PointAdd(pts[i], [0, 0, b_lst[1]]) rs.AddCylinder(pts[i], base, b_lst[4])
def createCylinder(): cylinderRadius = rs.GetReal(message='Of what radius? ', minimum=0.1) x1, y1, z1 = [float(n) for n in raw_input('From where?: "x y z"').split()] x2, y2, z2 = [float(n) for n in raw_input('To where?: "x y z"').split()] id = rs.AddCylinder((x1, y1, z1), (x2, y2, z2), cylinderRadius, cap=True) cylinders.append(id) rs.SetUserText(id, key="Cylinder", value=str(len(cylinders))) print('Done.')
def drawEdge(self,nodes): p1 = self.posVec p2 = nodes[self.parentID].posVec self.geom.append(rs.AddLine(p1,p2)) pNormal = rs.VectorSubtract(p2,p1) height = rs.VectorLength(pNormal) plane = rs.PlaneFromNormal(p1,pNormal) radius = self.radius self.geom.append(rs.AddCylinder(plane,height,radius))
def PlaceCircle(x, y, radius, layer): if (layer != 1) and (layer != 16): return None object = rs.AddCylinder((x, y, 0), 0.1, radius) index = rs.AddMaterialToObject(object) if layer == 1: rs.MaterialColor(index, (255, 0, 0)) if layer == 16: rs.MaterialColor(index, (0, 0, 255)) rs.MoveObject(object, (0, 0, -boardThickness - 0.1)) return object
def cylinders(self, num): a = rs.GetPoint("Enter start point") p = rs.AddPoint(a) h = rs.GetReal("Enter the height") for i in range(0, num): a.X = a.X + 4 h = h + 5 r = 2 cylinder = rs.AddCylinder(a, h, r) color02 = [i * 3, i * 2, 255 - i * 6] #magenta rs.ObjectColor(cylinder, color02)
def CreateCircle(): # user input for sizes # center = rs.GetPoint("Center point of circle") total_num = rs.GetInteger("total number of circs? ") for i in range(total_num): x = random.randint(-30, 30) y = random.randint(-30, 30) z = random.randint(0, 15) radius = random.randint(5, 20) height = random.randint(5, 50) objectID = rs.AddCylinder((x, y, z), height, radius) print objectID
def main(): cyls = [] radius = 0 gname = "Enclosure" extantGroups = rs.GroupNames() print "groups: ", extantGroups enclosures = [s for s in extantGroups if "Enclosure" in s] print "enclosures: ", enclosures if rs.IsGroup("Enclosure"): num = len(enclosures) gname += "_" + ` num ` encGroup = rs.AddGroup(gname) print "group: ", encGroup focus = rs.GetPoint("center of fence") if (focus is None): return rpt = rs.GetPoint("enclosure radius", focus) if (rpt is None): return else: radius = (rpt - focus).Length rs.AddObjectsToGroup(rs.AddCircle(focus, radius), encGroup) count = rs.GetInteger("number of cylinders") if (count is None): return cyldiam = rs.GetReal("cylinder diameter") if (cyldiam is None): return minheight = rs.GetReal("minimum height") if (minheight is None): return maxheight = rs.GetReal("maximum height") if (maxheight is None): return # arcjitter = rs.GetReal("amount of arc jitter") # if (arcjitter is None): return # radialjitter = rs.GetReal("amount of radial jitter") # if (radialjitter is None): return for i in range(count): cyl = rs.AddCylinder(rpt, random.uniform(minheight, maxheight), cyldiam / 2, True) rs.RotateObject(cyl, focus, (360 / count) * (i + 1)) cyls.append(cyl) if cyls: rs.AddObjectsToGroup(cyls, encGroup) print "Enclosure built:" print "focus: (", focus, ")" print "radius:", radius print "cylinders:", count, "ranging from", minheight, "to", maxheight, "units in length."
def cylinder(self, r, h): p = rs.rs.PointCoordinates(self.point) cylinder = rs.AddCylinder(p, h, r)
rs.DeleteObjects(rs.ObjectsByLayer('Default')) filepath = '/Users/time/Documents/UW/04_code/dmg_helmholtz/data/panel_geometry.json' with open(filepath, 'r') as fp: data = json.load(fp) rs.AddTextDot('S', data['src']) hr_pts = data['hr_pts'] nr = data['nr'] nl = data['nl'] br = data['br'] bl = data['bl'] for i, hr_pt in enumerate(hr_pts): r = nr[i] npt = [hr_pt[0], hr_pt[1], hr_pt[2] - nl[i]] # bpt = [hr_pt[0], hr_pt[1], hr_pt[2] - nl = bl] rs.AddCylinder(hr_pt, -nl[i], r, cap=False) rs.AddCylinder(npt, -bl[i], br[i], cap=False) recs = data['recs'] ps = data['pressures'] minp = min(ps) maxp = max(ps) for i, rec in enumerate(recs): pt = rs.AddPoint(rec) p = ps[i] i = (((p - minp) * (1 - 0)) / (maxp - minp)) + 0 color = i_to_rgb(i) rs.ObjectColor(pt, color)
def PlaceCircle(x, y, radius, layer): if (layer != 1) and (layer != 16): return None object = rs.AddCylinder((x, y, 0), 0.1, radius) ColorAndMove(object, layer) return object
fscrv = [pfCurves,ftipArc] fscrv = flatten(fscrv) """ bfCurves = [] bbCurves = [] _tipArc = rs.ProjectCurveToSurface(_tipArc, cylsrf[8], (0, 0, -1)) for i in range(8): bfCurves.append(pfCurves[i]) bbCurves.append(pbCurves[i]) bfCurves.append(_tipArc) bbCurves.append(_tipArc) faceSurface = rs.AddLoftSrf(bfCurves) backSurface = rs.AddLoftSrf(bbCurves) bSrf = rs.JoinSurfaces((faceSurface, backSurface)) allBlades = [] for i in range(Z): allBlades.append( rs.RotateObject(bSrf, cPoint, (360 / Z) * i, (1, 0, 0), True)) hub = rs.AddCylinder(rs.WorldYZPlane(), hl, .2 * D / 2) hub = rs.MoveObject(hub, (-hl / 1.5, 0, 0)) Geo = [allBlades, hub] Geo = flatten(Geo)
def __generate_individual_levels(self, crosssectionplane, loft_height): cplane = rs.ViewCPlane(None, crosssectionplane) level_points = [] spikiness = self.emotion_properties["spikiness"] # max spikiness = 1 scaling_factor_aid = 0.2 * spikiness #draws profile curves on each spine level for i in xrange(self.emotion_properties["horizontal_AR"][loft_height] ["points_in_curve"]): scaling_factor = 1 - scaling_factor_aid if i % 2 == 0 else 1 #ranges from a difference in 0.8 and 1 (no difference) angle = 2 * math.pi * i / self.emotion_properties["horizontal_AR"][ loft_height]["points_in_curve"] x_point = scaling_factor * self.dimensions[ "actual_height"] * self.dimensions[ "vertical_AR"] * self.emotion_properties["vertical_AR"][ loft_height] * self.emotion_properties[ "horizontal_AR"][loft_height][ "level_horizontal_AR_x"] * math.cos(angle) / 2 y_point = scaling_factor * self.dimensions[ "actual_height"] * self.dimensions[ "vertical_AR"] * self.emotion_properties["vertical_AR"][ loft_height] * self.emotion_properties[ "horizontal_AR"][loft_height][ "level_horizontal_AR_y"] * math.sin(angle) / 2 z_point = 0 point = rs.XformCPlaneToWorld([x_point, y_point, z_point], cplane) level_points.append(rs.AddPoint(point)) connecting_point = level_points[0] level_points.append(rs.AddPoint(connecting_point)) level_curve = rs.AddCurve( level_points, self.emotion_properties["horizontal_AR"][str( loft_height)]["horizontal_smoothness"]) #twists curve start point 180deg if it is below the spine_x point (to make sure loft doesn't twist) crvStart = rs.CurveStartPoint(level_curve) if crvStart[0] <= self.x_points[int(loft_height) - 1]: crvDomain = rs.CurveDomain(level_curve) rs.CurveSeam(level_curve, (crvDomain[0] + crvDomain[1]) / 2) # add planar surface to top and bottom of bottle if loft_height == "5" or loft_height == "1": rs.AddPlanarSrf(level_curve) # hide curves and points on level profiles rs.HideObjects(level_curve) rs.HideObjects(level_points) # object finishing features if (self.object_id == "Bottle"): if loft_height == "5": rs.AddCylinder(cplane, 14.5, 7.4, cap=True) if (self.object_id == "Chair"): if loft_height == "5": rs.AddCylinder(cplane, 14.5, 7.4, cap=True) if (self.object_id == "Jewelry"): if loft_height == "5": major_radius = 5.0 minor_radius = major_radius - 1.5 # rotated_cplane = rs.RotatePlane(cplane, 45.0, cplane.XAxis) direction = rs.AddPoint((0, 0, 1)) rs.AddTorus(cplane.Origin, major_radius, minor_radius, direction) if (self.object_id == "Totem"): if loft_height == "1": base_width = 80 base_length = 60 base_depth = -10 base_points = [(-base_width / 2, -base_length / 2, 0), (base_width / 2, -base_length / 2, 0), (base_width / 2, base_length / 2, 0), (-base_width / 2, base_length / 2, 0), (-base_width / 2, -base_length / 2, base_depth), (base_width / 2, -base_length / 2, base_depth), (base_width / 2, base_length / 2, base_depth), (-base_width / 2, base_length / 2, base_depth)] rs.AddBox(base_points) return level_curve
def make_hinge(num_knuckles, knuckle_height, knuckle_radius, thickness, leaf_length, gap, add_vents): origin = [0, 0, 0] hinge_height = num_knuckles * knuckle_height ###################################################################### # Make pin with caps cap_radius = knuckle_radius - 0.5 * thickness - gap cap_height = thickness cap_bottom = rs.AddCylinder(origin, cap_height, cap_radius) cap_top = rs.AddCylinder([0, 0, hinge_height - cap_height], cap_height, cap_radius) pin_radius = knuckle_radius - (gap + thickness) pin = rs.AddCylinder(origin, hinge_height, pin_radius) pin = rs.BooleanUnion([pin, cap_bottom, cap_top]) ###################################################################### # Make knuckle and holes right_knuckle = rs.AddCylinder(origin, hinge_height, knuckle_radius) knuckle_pin_hole = rs.AddCylinder(origin, hinge_height, knuckle_radius - thickness) knuckle_bottom_hole = rs.AddCylinder(origin, cap_height + gap, cap_radius + gap) knuckle_top_hole = rs.AddCylinder([0, 0, hinge_height - cap_height - gap], cap_height + gap, cap_radius + gap) ###################################################################### # Make leaves right_p0 = (0, knuckle_radius, 0) right_p1 = (leaf_length, knuckle_radius - thickness, hinge_height) right_leaf = rs.AddBox(mz.box_verts_from_corners(right_p0, right_p1)) right_leaf = rs.BooleanUnion([right_knuckle, right_leaf]) right_leaf, = rs.BooleanDifference( [right_leaf], [knuckle_pin_hole, knuckle_bottom_hole, knuckle_top_hole]) mirror_leaf = rs.XformMirror(origin, (1, 0, 0)) left_leaf = rs.TransformObject(right_leaf, mirror_leaf, True) ###################################################################### # Cut out alternating knuckles z0 = 0 sz = knuckle_radius + gap left_boxes = [] right_boxes = [] vent_height = knuckle_height - 4 * thickness for stage in range(num_knuckles): z1 = z0 + knuckle_height if stage == 0: cur_z0 = z0 else: cur_z0 = z0 - 0.5 * gap if stage == num_knuckles - 1: cur_z1 = z1 else: cur_z1 = z1 + 0.5 * gap knuckle_box = rs.AddBox( mz.box_verts_from_corners((-sz, -sz, cur_z0), (sz, sz, cur_z1))) if stage % 2 == 0: left_boxes.append(knuckle_box) else: right_boxes.append(knuckle_box) if add_vents: zmid = z0 + 0.5 * knuckle_height za = zmid - 0.5 * vent_height zb = zmid + 0.5 * vent_height mid_box = rs.AddBox( mz.box_verts_from_corners((-sz, -pin_radius - gap, za), (sz, pin_radius + gap, zb))) if stage % 2 == 0: right_boxes.append(mid_box) else: left_boxes.append(mid_box) z0 += knuckle_height left_leaf, = rs.BooleanDifference([left_leaf], left_boxes) right_leaf, = rs.BooleanDifference([right_leaf], right_boxes) rs.SelectObjects([left_leaf, right_leaf, pin]) rs.Command('MergeAllFaces')
import rhinoscriptsyntax as rs Radius = 50 radius = 3.0 height = 100 rs.AddCone((0, 0, 0), height, Radius, True) rs.AddCylinder((20, 0, 0), height, Radius, True) rs.AddSphere((40, 0, 6), Radius) rs.AddTorus((60, 0, 3), Radius, radius)
def TreeMassing(): try: litre = rs.GetReal("Enter the root ball litres, max 2000 Litres", 400) soilDepth = rs.GetReal('Enter the soil depth available in m', 0.8) matureHeight = rs.GetReal('Enter the mature tree height in m', 5) dbh = rs.GetReal( 'Enter the DBH at maturity in m, if unknown hit Enter', 0) userPt = rs.GetPoint('Pick a point to place rootball') rs.EnableRedraw(False) # Dictionery for litre size to pot Rootball Diameter [0] / Rootball Height [1] / Calliper [2] / Height [3] / Spread [4] # Figures obtained from https://winterhill.com.au/tree-sizes/ PotDict = { 25: [0.300, 0.250, 0.020, 1.000, 0.500], 45: [0.420, 0.350, 0.025, 2.000, 1.000], 75: [0.465, 0.500, 0.035, 2.500, 2.000], 100: [0.520, 0.560, 0.050, 3.500, 2.000], 200: [0.700, 0.625, 0.070, 4.500, 3.000], 400: [0.980, 0.715, 0.090, 6.000, 4.000], 600: [1.200, 0.600, 0.100, 6.000, 5.000], 800: [1.300, 0.600, 0.120, 7.000, 5.000], 1000: [1.500, 0.600, 0.150, 8.000, 5.000], 2000: [2.000, 0.800, 0.200, 9.000, 5.000], } def closest(lst, K): return lst[min(range(len(lst)), key=lambda i: abs(lst[i]-K))] def scale(): system = rs.UnitSystem() if system == 2 or system == 3 or system == 4: scaleFactorDict = {2: 1000, 3: 100, 4: 1} scaleFactor = scaleFactorDict[system] return scaleFactor if system != 2 or system != 3 or system != 4: return None s = scale() if s == None: rs.MessageBox( "This tool is can only be used in mm, cm or m model units") return None # Calc for standard soil requirements as per Australian Standards if dbh == 0: dbh = ((matureHeight / 100) * 4) * 1000 # Gives a DBH in mm # Gives a required soil volume in M3 reqSoil = (matureHeight * dbh) / 100 reqSoilRadius = math.sqrt(reqSoil / ((math.pi)*soilDepth)) # Add soil puck to doc reqSoilRadiusCyl = rs.AddCylinder( userPt, (soilDepth*s), (reqSoilRadius*s), cap=True) rs.ObjectColor(reqSoilRadiusCyl, (150, 75, 0)) # Calc for size of rootball as per standard pot sizes litreMatch = closest(list(PotDict.keys()), litre) dia = (PotDict[litreMatch])[0] height = (PotDict[litreMatch])[1] # Add Rootball to doc rootballCyl = rs.AddCylinder(userPt, (height*s), ((dia/2)*s)) rs.ObjectColor(rootballCyl, (0, 128, 0)) vec = (0, 0, ((soilDepth*s) - (height*s))) rs.MoveObject(rootballCyl, vec) # Add Tree model based on Dict calliper = (PotDict[litreMatch])[2] treeHeight = (PotDict[litreMatch])[3] spread = (PotDict[litreMatch])[4] vec02 = (0, 0, (((soilDepth*s) - (height*s))) + (height*s)) treeTrunk = rs.AddCylinder(userPt, (treeHeight*s), (calliper*s)) rs.ObjectColor(treeTrunk, (101, 67, 33)) rs.MoveObject(treeTrunk, vec02) canopy = rs.AddSphere(userPt, ((spread/2)*s)) rs.ObjectColor(canopy, (33, 101, 67)) vec03 = (0, 0, (((soilDepth*s) - (height*s))) + (height*s) + (treeHeight*s) - ((spread/2)*s)) rs.MoveObject(canopy, vec03) # Various Text Annotation txt1 = rs.AddText('Rootball ' + 'Height = ' + str(height*s) + ', Diameter = ' + str(dia*s), userPt, height=(.1*s), font="Arial", font_style=0, justification=2) txt2 = rs.AddText('Soil Volume Requirement = ' + str(reqSoil) + ' m3', (userPt.X, (userPt.Y - (.2*s)), userPt.Z), height=(.1*s), font="Arial", font_style=0, justification=2) block = rs.AddBlock((reqSoilRadiusCyl, rootballCyl, treeTrunk, canopy, txt1, txt2), userPt, ("Rootball and Soil " + (str(random.random()))), delete_input=True) rs.BlockDescription(block, 'Rootball ' + 'Height = ' + str(height*s) + ', Diameter = ' + str(dia*s) + ', Soil Volume Requirement = ' + str(reqSoil) + ' m3') guid = rs.InsertBlock(block, userPt) rs.ObjectName(guid, 'Rootball ' + 'Height = ' + str(height*s) + ', Diameter = ' + str(dia*s) + ', Soil Volume Requirement = ' + str(reqSoil) + ' m3') rs.EnableRedraw(True) except: print("Failed to execute") rs.EnableRedraw(True) return
def twig_gen(self, base_radius, top_radius, height): return rs.AddCylinder(rs.WorldXYPlane(), height, base_radius)
import rhinoscriptsyntax as rs all = rs.AllObjects() rs.DeleteObjects(all) plane1 = rs.PlaneFromFrame([0, 0, 0], [0, 1, 0], [1, 0, 0]) plane2 = rs.PlaneFromFrame([0, 0, 6], [0, 1, 0], [1, 0, 0]) plane3 = rs.PlaneFromFrame([0, 0, 40], [0, 1, 0], [1, 0, 0]) nose = rs.AddCone(plane2, 6, 20, cap=True) nose2 = rs.AddCone(plane3, 24, 5, cap=True) hat1 = rs.AddCylinder(plane1, 110, 20, cap=True) hat2 = rs.AddCylinder(plane1, -6, 10, cap=True) hat3 = rs.AddCylinder(plane2, -10, 12, cap=True) ##neck=rs.AddCylinder ((0,0,-35), 10, 5, cap=True)
import rhinoscriptsyntax as rs # rs.AddPoint( - syntax tip myPoint = rs.AddPoint((1, 2, 3)) # rs.AddSphere(center, radius) myRadius = 3 mySpere = rs.AddSphere(myPoint, myRadius) # skapa en kone myCone = rs.AddCone((1, 2, 3), 20, 10) # skapa en cylinder myCone = rs.AddCylinder((0, -10, 0), 2, 10) # skapa en linje myPoint_2 = rs.AddPoint((0, 0, 0)) myPoint_3 = rs.AddPoint((10, 0, 0)) rs.AddLine(myPoint_2, myPoint_3)
def createCylinderCake(): for i in range(10): point1 = rs.CreatePoint(0, 0, -i) rs.AddCylinder(point1, 10, i)
base_btm_origin, (-BEAM_HEIGHT * tan(pi/3), -BEAM_HEIGHT * tan(pi/3), BEAM_HEIGHT)) ) base = rss.BooleanUnion(( rss.JoinSurfaces( [rss.AddSrfPt(base_btm_pts), rss.AddSrfPt(base_top_pts)] + quad_rotate_object(rss.AddSrfPt(( base_btm_pts[0], base_btm_pts[1], base_top_pts[0], base_top_pts[1] ))), delete_input=True ), rss.AddCylinder((0, 0, 0), 107.5, CORE_RADIUS) )) # Part 1: Layer 1 # PLANE_HEIGHT: Height where the layer is placed PLANE_HEIGHT = 62.5 if BUILD_TARGET == 'all' or 'layer1' in BUILD_TARGET: beam_origin = (BEAM_HALF_LENGTH, CORE_RADIUS, PLANE_HEIGHT) beam_path = rss.AddPolyline(( beam_origin, rss.PointAdd(beam_origin, (0, 0, 8)), rss.PointAdd(beam_origin, (-5, 0, BEAM_HEIGHT)), rss.PointAdd(beam_origin, (-BEAM_LENGTH + 5, 0, BEAM_HEIGHT)),
z = rs.AddPoint(0, 1, -.4) j = 0 plane11 = rs.RotatePlane(plane1, 0, [0, 1, 0]) #for i in range(50): #plane11 = rs.RotatePlane(plane1, j, [0,1,0]) #j=j+10 #rs.AddRectangle( plane11, 25.0, 25.0 ) #rs.AddCircle( plane11, 25.0 ) #rs.AddSphere ( plane11, 25.0 ) #plane11 = rs.RotatePlane(plane1, j, [0,0,1]) #j=j+10 #rs.AddRectangle( plane11, 25.0, 25.0 ) #rs.AddSphere ( plane11, 50.0 )\ head = rs.AddSphere(plane11, 25.0) eyeL = rs.AddSphere(plane2, 5.0) eyeR = rs.AddSphere(plane3, 5.0) #rs.AddSphere ( plane11, 25.0 ) #rs.AddCircle( (0,0,25), 50.0 ) hat1 = rs.AddCone(plane5, -25, 25, cap=False) nose = rs.AddCone(plane4, 15, 5, cap=True) hat2 = rs.AddCylinder(plane6, -1, 50, cap=True) hat2 = rs.AddTorus(plane6, 50, 2) neck = rs.AddCylinder((0, 0, -30), 10, 5, cap=True) #body=rs.AddCylinder ((0,0,-70), 40, 50, cap=True) body = rs.AddCylinder((0, 0, -95), 60, 30, cap=True) #body=rs.GetRectangle (4, (0,0,-130),) collar = rs.AddTorus((0, 0, -35), 15, 5)
def cylinder(self, r): a = rs.GetPoint("Enter start point") h = rs.GetReal("Enter the height") cylinder = rs.AddCylinder(a, h, r)
# use rhinoscriptsyntax to get all the functions in one shot import rhinoscriptsyntax as rs import random import time import math import Rhino numCyls = rs.GetInteger("Number of sticks") spread = rs.GetInteger("spread") seed = rs.GetPoint("seed point") print "seed point: ", seed[0], " / ", seed[1], " / ", seed[2] pi = math.pi if numCyls and spread and seed: for a in range(numCyls): x = seed[0] y = seed[1] z = seed[2] # points.append([seed[0], seed[1], seed[2]]) offset = random.random() * spread stick = rs.AddCylinder([x + offset, y, z], random.random() * 10, random.random() * 0.5, True) rs.RotateObject(stick, seed, random.random() * 360) rs.ZoomExtents(view=None, all=True)
def createCylinderVisual(_space): for i in range(10): point1 = rs.CreatePoint(i * spacing, 0, 0) rs.AddCylinder(point1, random.randint(1, spacing), random.randint(1, spacing / 2))
def createColoredCylinder(x, y, z, r, g, b): currentColor = [r, g, b] rs.AddPoint(x, y, z) pt = (x, y, z) cr = rs.AddCylinder(pt, (x + y) / 4, 5) rs.ObjectColor(cr, currentColor)