def main( x, y, r ): border = draw_circle.main( x, y, r ) temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] length = len( border ) for i in range( length - 1 ): for t in range( 1, length ): if border[ i ].y == border[ t ].y: fill = draw_line.main( border[ i ].x, border[ i ].y, border[ t ].x, border[ t ].y ) length2 = len( fill ) for e in range( length2 ): temp.x = fill[ e ].x temp.y = fill[ e ].y points.append( copy.deepcopy( temp ) ) #end e for loop #end of if-else statement #end of t for loop #end of i for loop del points[ 0 ] return points
def main(*args): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] length = len(args) for x1 in range(0, length - 3, 2): y1 = x1 + 1 x2 = y1 + 1 y2 = x2 + 1 line = draw_line.main(args[x1], args[y1], args[x2], args[y2]) length2 = len(line) for i in range(length2): temp.x = line[i].x temp.y = line[i].y points.append(copy.deepcopy(temp)) line = draw_line.main(args[length - 2], args[length - 1], args[0], args[1]) length2 = len(line) for i in range(length2): temp.x = line[i].x temp.y = line[i].y points.append(copy.deepcopy(temp)) del points[0] return points
def main( *args ): temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] length = len( args ) for x1 in range( 0, length - 3, 2 ): y1 = x1 + 1 x2 = y1 + 1 y2 = x2 + 1 line = draw_line.main( args[ x1 ], args[ y1 ], args[ x2 ], args[ y2 ] ) length2 = len( line ) for i in range( length2 ): temp.x = line[ i ].x temp.y = line[ i ].y points.append( copy.deepcopy( temp ) ) line = draw_line.main( args[ length - 2 ], args[ length - 1 ], args[ 0 ], args[ 1 ] ) length2 = len( line ) for i in range( length2 ): temp.x = line[ i ].x temp.y = line[ i ].y points.append( copy.deepcopy( temp ) ) del points[ 0 ] return points
def main(x1, y1, x2, y2, x3, y3, xt, yt, xf, yf, d, xs, ys): points = [] temp = one_color.struc() line1 = translation.main(x1, y1, x2, y2, xt, yt) line2 = translation.main(x2, y2, x3, y3, xt, yt) line3 = translation.main(x3, y3, x1, y1, xt, yt) line1 = rotation.main(line1[0].x, line1[0].y, line1[1].x, line1[1].y, xf, yf, d) line2 = rotation.main(line2[0].x, line2[0].y, line2[1].x, line2[1].y, xf, yf, d) line3 = rotation.main(line3[0].x, line3[0].y, line3[1].x, line3[1].y, xf, yf, d) line1 = scale.main(line1[0].x, line1[0].y, line1[1].x, line1[1].y, xf, yf, xs, ys) line2 = scale.main(line2[0].x, line2[0].y, line2[1].x, line2[1].y, xf, yf, xs, ys) line3 = scale.main(line3[0].x, line3[0].y, line3[1].x, line3[1].y, xf, yf, xs, ys) line = draw_polygon.main(line1[0].x, line1[0].y, line2[0].x, line2[0].y, line3[0].x, line3[0].y) return line
def main(d, xl, yl, sf, args): display = [] transP = [] scaleP = [] temp = one_color.struc() #get projection points line = projection.main(d, args) length = len(line) #Find center point and max values xMax = line[0].x xMin = line[0].x yMax = line[0].y yMin = line[0].y for i in range(length): if line[i].x > xMax: xMax = line[i].x if line[i].x < xMin: xMin = line[i].x if line[i].y > yMax: yMax = line[i].y if line[i].x < xMin: yMin = line[i].y xc = (xMax + xMin) / 2 yc = (yMax + yMin) / 2 #Find translation amount based on center xt = xl - xc yt = yl - yc #Composite #translate, scale, and draw a line based on the points found for i in range(0, len(line) - 1, 2): point = translation.main(line[i].x, line[i].y, line[i + 1].x, line[i + 1].y, xt, yt) for i in range(len(point)): temp.x = point[i].x temp.y = point[i].y transP.append(copy.deepcopy(temp)) for i in range(0, len(transP) - 1, 2): point = scale.main(transP[i].x, transP[i].y, transP[i + 1].x, transP[i + 1].y, xl, yl, sf, sf) for i in range(len(point)): temp.x = point[i].x temp.y = point[i].y scaleP.append(copy.deepcopy(temp)) for i in range(0, len(scaleP) - 1, 2): point = draw_line.main(scaleP[i].x, scaleP[i].y, scaleP[i + 1].x, scaleP[i + 1].y) for i in range(len(point)): temp.x = point[i].x temp.y = point[i].y display.append(copy.deepcopy(temp)) return display
def checker(boardsize_x, boardsize_y, blocksize_x, blocksize_y): print('Starting') xwt = 0 ywt = 0 temp = one_color.struc() bluepoints = [copy.deepcopy(one_color.struc)] redpoints = [copy.deepcopy(one_color.struc)] for y in range(boardsize_y): t2 = y % blocksize_y if t2 == 0: ywt = ywt + 1 #end if on t2 ywt2 = ywt % 2 if ywt2 == 1: n = 1 elif ywt2 == 0: n = 2 #end if on ywt2 for x in range(boardsize_x): temp.x = x temp.y = y t = x % blocksize_x if t == 0: xwt = xwt + 1 #end if on t xwt2 = xwt % 2 if n == 1: if xwt2 == 1: bluepoints.append(copy.deepcopy(temp)) elif xwt2 == 0: redpoints.append(copy.deepcopy(temp)) #end if on xwt2 elif n == 2: if xwt2 == 1: redpoints.append(copy.deepcopy(temp)) elif xwt2 == 0: bluepoints.append(copy.deepcopy(temp)) #end if on xwt2 #end if on n #end for loop on x #end for loop on y del redpoints[0] #remove unused location del bluepoints[0] #remove unused location image = one_color.main(boardsize_x, boardsize_y, 255, 255, 255) image = add_to_image.main(image, redpoints, 255, 0, 0) image = add_to_image.main(image, bluepoints, 0, 0, 255) write_ppm.main(image, 'test') print('Finish')
def checker( boardsize_x, boardsize_y, blocksize_x, blocksize_y ): print ('Starting') xwt = 0 ywt = 0 temp = one_color.struc() bluepoints = [ copy.deepcopy( one_color.struc ) ] redpoints = [ copy.deepcopy( one_color.struc ) ] for y in range( boardsize_y ): t2 = y%blocksize_y if t2 == 0: ywt = ywt + 1 #end if on t2 ywt2 = ywt%2 if ywt2 == 1: n = 1 elif ywt2 == 0: n = 2 #end if on ywt2 for x in range( boardsize_x ): temp.x = x temp.y = y t = x%blocksize_x if t == 0: xwt = xwt + 1 #end if on t xwt2 = xwt%2 if n == 1: if xwt2 == 1: bluepoints.append( copy.deepcopy( temp ) ) elif xwt2 == 0: redpoints.append( copy.deepcopy( temp ) ) #end if on xwt2 elif n == 2: if xwt2 == 1: redpoints.append( copy.deepcopy( temp ) ) elif xwt2 == 0: bluepoints.append( copy.deepcopy( temp ) ) #end if on xwt2 #end if on n #end for loop on x #end for loop on y del redpoints[ 0 ] #remove unused location del bluepoints[ 0 ] #remove unused location image = one_color.main( boardsize_x, boardsize_y, 255, 255, 255 ) image = add_to_image.main( image, redpoints, 255, 0, 0 ) image = add_to_image.main( image, bluepoints, 0, 0, 255 ) write_ppm.main( image, 'test' ) print ('Finish')
def main(x1, y1, x2, y2, xt, yt): temp = one_color.struc() points = [] temp.x = x1 + xt temp.y = y1 + yt points.append(copy.deepcopy(temp)) temp.x = x2 + xt temp.y = y2 + yt points.append(copy.deepcopy(temp)) return points
def line(x1, y1, x2, y2): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] increment = 1 #Find absolute value of x length, y length x_length = abs(x1 - x2) y_length = abs(y1 - y2) #compare x length, y length, if x length is longer... if x_length >= y_length: m = float(y2-y1)/float(x2-x1) # slope b = (-(float(y2-y1)/float(x2-x1)))*x1 + y1 # y-intercept #Find integer values from x1 to x2 for x in range(x1, x2+1): temp.x = x #solve for corresponding y values using Eq. 2.1 y_value = m * x + b #Round y values to nearest integer value y_value = round(y_value) temp.y = int(y_value) #add x and y values to data structure points.append(copy.deepcopy(temp)) #compare x length, y length, if y length is longer... elif y_length > x_length: m_inverse = float(x2-x1)/float(y2-y1) # slope inverse #Find integer values from y1 to y2 for y in range(y1, y2+1): temp.y = y #solve for corresponding x values using Eq. 2.4 x_value = m_inverse*y - m_inverse*y1 + x1 #Round x values to nearest integer value x_value = round(x_value) temp.x = int(x_value) #add x and y values to data structure points.append(copy.deepcopy(temp)) del points[0] # remove unused location return points
def line(x1, y1, x2, y2): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] increment = 1 #Find absolute value of x length, y length x_length = abs(x1 - x2) y_length = abs(y1 - y2) #compare x length, y length, if x length is longer... if x_length >= y_length: m = float(y2 - y1) / float(x2 - x1) # slope b = (-(float(y2 - y1) / float(x2 - x1))) * x1 + y1 # y-intercept #Find integer values from x1 to x2 for x in range(x1, x2 + 1): temp.x = x #solve for corresponding y values using Eq. 2.1 y_value = m * x + b #Round y values to nearest integer value y_value = round(y_value) temp.y = int(y_value) #add x and y values to data structure points.append(copy.deepcopy(temp)) #compare x length, y length, if y length is longer... elif y_length > x_length: m_inverse = float(x2 - x1) / float(y2 - y1) # slope inverse #Find integer values from y1 to y2 for y in range(y1, y2 + 1): temp.y = y #solve for corresponding x values using Eq. 2.4 x_value = m_inverse * y - m_inverse * y1 + x1 #Round x values to nearest integer value x_value = round(x_value) temp.x = int(x_value) #add x and y values to data structure points.append(copy.deepcopy(temp)) del points[0] # remove unused location return points
def main( d, args ): temp = one_color.struc() points = [] #Turns every XYZ coordinate to its 2D equivalent length = len( args ) for i in range( 0, length - 2, 3 ): yAP1 = ( args[ i + 1 ] * d ) / args[ i + 2 ] xAP1 = ( args[ i ] * d ) / args[ i + 2 ] temp.x = xAP1 temp.y = yAP1 points.append( copy.deepcopy( temp ) ) return points
def main(line, scan): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] lineMax = 0 length = len(line) if line[0].y < line[length - 1].y: start = line[0].y end = line[length - 1].y else: start = line[length - 1].y end = line[0].y #Line if line[length - 1].y - line[0].y == 0: #This is a horizontal line del points[0] return points #If scan line is not within the edge if scan not in range(start, end): del points[0] return points else: if line[0].y >= line[length - 1].y: #y1 is maximum lineMax = line[0].y elif line[0].y < line[length - 1].y: #y2 is maximum lineMax = line[length - 1].y if scan == lineMax: #Max vertex point, no intersection del points[0] return points elif scan in range(start, end) and scan != lineMax: frac = (line[length - 1].x - line[0].x) / (line[length - 1].y - line[0].y) first = frac * scan second = (frac * line[0].y) third = first - second newX = third + line[0].x temp.x = round(newX) temp.y = scan points.append(copy.deepcopy(temp)) del points[0] return points
def main( line, scan ): temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] lineMax = 0 length = len( line ) if line[ 0 ].y < line[ length - 1 ].y: start = line[ 0 ].y end = line[ length - 1 ].y else: start = line[ length - 1 ].y end = line[ 0 ].y #Line if line[ length - 1 ].y - line[ 0 ].y == 0: #This is a horizontal line del points[ 0 ] return points #If scan line is not within the edge if scan not in range( start, end ): del points[ 0 ] return points else: if line[ 0 ].y >= line[ length - 1 ].y: #y1 is maximum lineMax = line[ 0 ].y elif line[ 0 ].y < line[ length - 1 ].y: #y2 is maximum lineMax = line[ length - 1 ].y if scan == lineMax: #Max vertex point, no intersection del points[ 0 ] return points elif scan in range( start, end ) and scan != lineMax: frac = ( line[ length - 1 ].x - line[ 0 ].x ) / ( line[ length - 1 ].y - line[ 0 ].y ) first = frac * scan second = ( frac * line[ 0 ].y ) third = first - second newX = third + line[ 0 ].x temp.x = round( newX ) temp.y = scan points.append( copy.deepcopy( temp ) ) del points[ 0 ] return points
def main( x1, y1, x2, y2, x3, y3, xt, yt, xf, yf, d, xs, ys ): points = [] temp = one_color.struc() line1 = translation.main( x1, y1, x2, y2, xt, yt ) line2 = translation.main( x2, y2, x3, y3, xt, yt ) line3 = translation.main( x3, y3, x1, y1, xt, yt ) line1 = rotation.main( line1[ 0 ].x, line1[ 0 ].y, line1[ 1 ].x, line1[ 1 ].y, xf, yf, d ) line2 = rotation.main( line2[ 0 ].x, line2[ 0 ].y, line2[ 1 ].x, line2[ 1 ].y, xf, yf, d ) line3 = rotation.main( line3[ 0 ].x, line3[ 0 ].y, line3[ 1 ].x, line3[ 1 ].y, xf, yf, d ) line1 = scale.main( line1[ 0 ].x, line1[ 0 ].y, line1[ 1 ].x, line1[ 1 ].y, xf, yf, xs, ys ) line2 = scale.main( line2[ 0 ].x, line2[ 0 ].y, line2[ 1 ].x, line2[ 1 ].y, xf, yf, xs, ys ) line3 = scale.main( line3[ 0 ].x, line3[ 0 ].y, line3[ 1 ].x, line3[ 1 ].y, xf, yf, xs, ys ) line = fill_polygon.main( line1[ 0 ].x, line1[ 0 ].y, line2[ 0 ].x, line2[ 0 ].y, line3[ 0 ].x, line3[ 0 ].y ) return line
def main( x, y, majA, minB ): border = draw_ellipse.main( x, y, majA, minB ) temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] length = len( border ) for i in range( length - 1 ): for t in range( 1, length ): if border[ i ].y == border[ t ].y: fill = draw_line.main( border[ i ].x, border[ i ].y, border[ t ].x, border[ t ].y ) length2 = len( fill ) for e in range( length2 ): temp.x = fill[ e ].x temp.y = fill[ e ].y points.append( copy.deepcopy( temp ) ) #end e for loop #end of if-else statement #end of t for loop #end of i for loop del points[ 0 ] return points
def fill_polygon(vertex_array): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #find min y-value (ymin) and max y-value (y-max) smallest = vertex_array[0][1] smallest_index = 0 largest = vertex_array[0][1] largest_index = 0 for i in range(0, len(vertex_array)): if vertex_array[i][1] < smallest: smallest = vertex_array[i][1] smallest_index = i if vertex_array[i][1] > largest: largest = vertex_array[i][1] largest_index = i smallest_holder = smallest #For all the scan lines from ymin to ymax: for k in range(smallest, largest+1): intersections = [] #For each edge: for j in range(0, len(vertex_array)): x_one = vertex_array[j][0] y_one = vertex_array[j][1] if j == len(vertex_array)-1: x_two = vertex_array[0][0] y_two = vertex_array[0][1] else: x_two = vertex_array[j+1][0] y_two = vertex_array[j+1][1] if y_two - y_one != 0: if (y_two <= smallest_holder <= y_one) or (y_one <= smallest_holder <= y_two): y_max = y_one # Find the y-value of the maximal vertex point if y_one >= y_two : y_max = y_one elif y_one < y_two : y_max = y_two if (smallest_holder != y_max) and ((y_two <= smallest_holder <= y_one) or (y_one <= smallest_holder <= y_two)): m_inverse = float(x_two-x_one)/float(y_two-y_one) # slope inverse x_value = m_inverse*smallest_holder - m_inverse*y_one + x_one x_value = int(round(x_value)) temp.x = x_value temp.y = smallest_holder intersections.append([temp.x, temp.y]) sorted(intersections, key=lambda x: x[0]) for i in range(0, len(intersections), 2): counter = 0 big_x = 0 small_x = 0 if intersections[i][0] > intersections[i+1][0]: big_x = intersections[i][0] small_x = intersections[i+1][0] else: big_x = intersections[i+1][0] small_x = intersections[i][0] for x in range(small_x, big_x+1): temp.x = small_x + counter temp.y = intersections[i][1] #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) counter = counter + 1 smallest_holder = smallest_holder + 1 del points[0] # remove unused location return points
def circle(radius, center_x, center_y): biglist = [] # data structure to hold points temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] # initialize starting point to (r,0) temp.x = radius temp.y = 0 # add points to temporary data structure biglist.append([temp.x, temp.y]) biglist.append([temp.y, temp.x]) biglist.append([-(temp.x), temp.y]) biglist.append([temp.y, -(temp.x)]) while True: # compute next y location for the first octant temp.y = temp.y + 1 # compute the corresponding x value for y + 1 using Eq. 2.6 temp.x = math.sqrt((pow(radius, 2.0)) - (pow(temp.y, 2.0))) # Round to the nearest integer value temp.x = int(round(temp.x)) # Check to see if points are still in first octant if temp.x == temp.y: # compute other points on the circle by symmetry # Don't compute duplicate coordinates biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) else: # compute other points on the circle by symmetry biglist.append([temp.x, temp.y]) biglist.append([temp.y, temp.x]) biglist.append([-(temp.y), temp.x]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([-(temp.y), -(temp.x)]) biglist.append([temp.y, -(temp.x)]) biglist.append([temp.x, -(temp.y)]) if temp.x <= temp.y: break # add center point to all points for i in range(0, len(biglist)): temp.x = biglist[i][0] + center_x temp.y = biglist[i][1] + center_y # add updated/finalized points to data structure points.append(copy.deepcopy(temp)) del points[0] # remove unused location return points
def fill_polygon(vertex_array): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #find min y-value (ymin) and max y-value (y-max) smallest = vertex_array[0][1] smallest_index = 0 largest = vertex_array[0][1] largest_index = 0 for i in range(0, len(vertex_array)): if vertex_array[i][1] < smallest: smallest = vertex_array[i][1] smallest_index = i if vertex_array[i][1] > largest: largest = vertex_array[i][1] largest_index = i smallest_holder = smallest #For all the scan lines from ymin to ymax: for k in range(smallest, largest + 1): ## print 'Scan line, y =', k intersections = [] #For each edge: for j in range(0, len(vertex_array)): x_one = vertex_array[j][0] y_one = vertex_array[j][1] if j == len(vertex_array) - 1: x_two = vertex_array[0][0] y_two = vertex_array[0][1] else: x_two = vertex_array[j + 1][0] y_two = vertex_array[j + 1][1] if y_two - y_one != 0: if (y_two <= smallest_holder <= y_one) or (y_one <= smallest_holder <= y_two): y_max = y_one # Find the y-value of the maximal vertex point if y_one >= y_two: y_max = y_one elif y_one < y_two: y_max = y_two if (smallest_holder != y_max) and ( (y_two <= smallest_holder <= y_one) or (y_one <= smallest_holder <= y_two)): m_inverse = float(x_two - x_one) / float( y_two - y_one) # slope inverse x_value = m_inverse * smallest_holder - m_inverse * y_one + x_one x_value = int(round(x_value)) temp.x = x_value temp.y = smallest_holder intersections.append([temp.x, temp.y]) ## print 'intersections before sorting', intersections # TODO: sorted algorthim/function not working intersections = sorted(intersections, key=lambda x: x[0]) ## print 'intersections', intersections, '\n' for i in range(0, len(intersections), 2): counter = 0 for m in range(intersections[i][0], intersections[i + 1][0]): temp.x = intersections[i][0] + counter temp.y = intersections[i][1] #DEBUG ## print 'temp x', temp.x, 'temp y', temp.y, '\n' #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) counter = counter + 1 smallest_holder = smallest_holder + 1 del points[0] # remove unused location return points
def ellipse(a,b, center_x, center_y): # a == major axis # b == minor axis biglist = [] #data structure to hold points temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #initialize starting point to (a,0) temp.x = a temp.y = 0 biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) while True: #check to see if in region 2 if ((pow(a, 2.0))*(temp.y +1)) < ((pow(b, 2.0))*(temp.x - 0.5)): #compute next y location for region 2 temp.y = temp.y +1 #compute the corresponding x value for y + 1 using Eq. 2.8 temp.x = math.sqrt( (pow(a, 2.0)) * ( 1 - ((pow(temp.y, 2.0))/(pow(b, 2.0))) ) ) #Round to the nearest integer value temp.x = int(round(temp.x)) #compute other points on the circle by symmetry biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) #check if still in region 2, if not move on if ((pow(a, 2.0))*(temp.y+1)) >= ((pow(b, 2.0))*(temp.x-.5)): break #if not in region 2, move on to region 1 else: break while True: #compute next x location for region 1 temp.x = temp.x - 1 #compute the y value for x - 1 using Eq. 2.9 temp.y = math.sqrt( (pow(b, 2.0)) * ( 1 - ((pow(temp.x, 2.0))/(pow(a, 2.0))) ) ) #Round to the nearest integer temp.y = int(round(temp.y)) #if x > 0, keep looping through looking to compute y values if temp.x == 0: biglist.append([temp.x, temp.y]) biglist.append([temp.x, -(temp.y)]) else: biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) if temp.x <= 0: break #add center point to all points for i in range(0, len(biglist)): temp.x = biglist[i][0] + center_x temp.y = biglist[i][1] + center_y biglist[i][0] = biglist[i][0] + center_x biglist[i][1] = biglist[i][1] + center_y #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) del points[0] # remove unused location return points
def fill_polygon(vertex_array): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #find min y-value (ymin) and max y-value (y-max) smallest = vertex_array[0][1] smallest_index = 0 largest = vertex_array[0][1] largest_index = 0 for i in range(0, len(vertex_array)): if vertex_array[i][1] < smallest: smallest = vertex_array[i][1] smallest_index = i if vertex_array[i][1] > largest: largest = vertex_array[i][1] largest_index = i #DEBUG print 'smallest', smallest, '||| largest', largest smallest_holder = smallest #For all the scan lines from ymin to ymax: for k in range(smallest, largest+1): intersections = [] #For each edge: for j in range(0, len(vertex_array)): x_one = vertex_array[j][0] y_one = vertex_array[j][1] if j == len(vertex_array)-1: x_two = vertex_array[0][0] y_two = vertex_array[0][1] else: x_two = vertex_array[j+1][0] y_two = vertex_array[j+1][1] if y_two - y_one != 0: if (y_two <= smallest_holder <= y_one) or (y_one <= smallest_holder <= y_two): y_max = y_one # Find the y-value of the maximal vertex point if y_one >= y_two : y_max = y_one elif y_one < y_two : y_max = y_two if (smallest_holder != y_max) and ((y_two <= smallest_holder <= y_one) or (y_one <= smallest_holder <= y_two)): m_inverse = float(x_two-x_one)/float(y_two-y_one) # slope inverse x_value = m_inverse*smallest_holder - m_inverse*y_one + x_one x_value = int(round(x_value)) temp.x = x_value temp.y = smallest_holder intersections.append([temp.x, temp.y]) sorted(intersections, key=lambda x: x[0]) for i in range(0, len(intersections), 2): counter = 0 big_x = 0 small_x = 0 if intersections[i][0] > intersections[i+1][0]: big_x = intersections[i][0] small_x = intersections[i+1][0] else: big_x = intersections[i+1][0] small_x = intersections[i][0] for x in range(small_x, big_x+1): temp.x = small_x + counter temp.y = intersections[i][1] #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) counter = counter + 1 smallest_holder = smallest_holder + 1 del points[0] # remove unused location return points
def main( *args ): temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] fillpoints = [ copy.deepcopy( one_color.struc ) ] del points[ 0 ] del fillpoints[ 0 ] #find the smallest and largest y values #will be used as the limit of scan line minY = args[ 0 ] maxY = args[ 0 ] length = len( args ) for i in range( 1, length, 2 ): if args[ i ] < minY: minY = args[ i ] elif args[ i ] > maxY: maxY = args[ i ] #end of if-else statement #end of i for loop print( 'Found scan borders' ) print( 'minY = ', minY ) print( 'maxY = ', maxY ) scan = minY + 1 start = 0 while scan < maxY: while start <= length - 4: #find scan intersection with all sides except last side y1 = start + 1 x2 = y1 + 1 y2 = x2 + 1 line = draw_line.main( args[ start ], args[ y1 ], args[ x2 ], args[ y2 ] ) point = scan_line.main( line, scan ) if len( point ) == 0: start = start + 2 else: points = points + point start = start + 2 #If on the last side find its scan intersection line = draw_line.main( args[ length - 2 ], args[ length - 1 ], args[ 0 ], args[ 1 ] ) point = scan_line.main( line, scan ) if len( point ) == 0: pass else: points = points + point #Begin of sort lengthp = len( points ) done = False head = 0 tail = 1 while done == True: check = 0 if check == lengthp - 1: done = False if tail >= lengthp: head = 0 tail = 1 if points[ head ].x > points[ tail ].x: temp = points[ tail ] points[ tail ] = points[ head ] points[ head ] = temp head = head + 1 tail = tail + 1 else: head = head + 1 tail = tail + 1 check = check + 1 #End of while loop #Get pairs of points that need to be filled head = 0 tail = 1 while head < lengthp - 1: fill = draw_line.main( points[ head ].x, points[ head ].y, points[ tail ].x, points[ tail ].y ) fillpoints = fillpoints + fill #end of i for loop head = head + 2 tail = tail + 2 del points[ : ] scan = scan + 1 start = 0 return fillpoints
def main( x1, y1, x2, y2 ): temp = one_color.struc() linepoints = [ copy.deepcopy( one_color.struc ) ] xLen = abs( x1 - x2 ) yLen = abs( y1 - y2 ) temp.x = x1 temp.y = y1 linepoints.append( copy.deepcopy( temp ) ) if xLen > yLen: if x2 > x1: for i in range( x1 + 1, x2 ): temp.x = i m = ( y2 - y1 ) / ( x2 - x1 ) first = -1 * m second = first * x1 b = second + y1 yPoint = ( m * i ) + b temp.y = round( yPoint ) linepoints.append( copy.deepcopy( temp ) ) #end for loop on i else: for i in range( x1 - 1, x2, -1 ): temp.x = i m = ( y2 - y1 ) / ( x2 - x1 ) first = -1 * m second = first * x1 b = second + y1 yPoint = ( m * i ) + b temp.y = round( yPoint ) linepoints.append( copy.deepcopy( temp ) ) #end for loop on i else: if y2 > y1: for t in range( y1 + 1, y2 ): temp.y = t #break function into smaller parts fraction = ( x2 - x1 ) / ( y2 - y1 ) first = fraction * t second = ( fraction * y1 ) third = first - second xPoint = third + x1 temp.x = round( xPoint ) linepoints.append( copy.deepcopy( temp ) ) #end for loop on t else: for t in range( y1 - 1, y2, -1 ): temp.y = t #break function into smaller parts fraction = ( x2 - x1 ) / ( y2 - y1 ) first = fraction * t second = ( fraction * y1 ) third = first - second xPoint = third + x1 temp.x = round( xPoint ) linepoints.append( copy.deepcopy( temp ) ) #end for loop on t #end if else statement temp.x = x2 temp.y = y2 linepoints.append( copy.deepcopy( temp ) ) del linepoints[ 0 ] #remove ununsed locatation length = len( linepoints ) return linepoints
def fill_ellipse(a,b, center_x, center_y): # a == major axis # b == minor axis biglist = [] #data structure to hold points temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #initialize starting point to (a,0) temp.x = a temp.y = 0 biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) while True: #check to see if in region 2 if ((pow(a, 2.0))*(temp.y +1)) < ((pow(b, 2.0))*(temp.x - 0.5)): #compute next y location for region 2 temp.y = temp.y +1 #compute the corresponding x value for y + 1 using Eq. 2.8 temp.x = math.sqrt( (pow(a, 2.0)) * ( 1 - ((pow(temp.y, 2.0))/(pow(b, 2.0))) ) ) #Round to the nearest integer value temp.x = int(round(temp.x)) #compute other points on the circle by symmetry biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) #check if still in region 2, if not move on if ((pow(a, 2.0))*(temp.y+1)) >= ((pow(b, 2.0))*(temp.x-.5)): break #if not in region 2, move on to region 1 else: break while True: #compute next x location for region 1 temp.x = temp.x - 1 #compute the y value for x - 1 using Eq. 2.9 temp.y = math.sqrt( (pow(b, 2.0)) * ( 1 - ((pow(temp.x, 2.0))/(pow(a, 2.0))) ) ) #Round to the nearest integer temp.y = int(round(temp.y)) #if x > 0, keep looping through looking to compute y values if temp.x == 0: biglist.append([temp.x, temp.y]) biglist.append([temp.x, -(temp.y)]) else: biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) if temp.x <= 0: break #add center point to all points for i in range(0, len(biglist)): temp.x = biglist[i][0] + center_x temp.y = biglist[i][1] + center_y biglist[i][0] = biglist[i][0] + center_x biglist[i][1] = biglist[i][1] + center_y #add updated/finalized points to data structure #points.append(copy.deepcopy(temp)) smallest = biglist[0][1] smallest_index = 0 largest = biglist[0][1] largest_index = 0 #Find minimum and maximum y values of the circle and their indexes for i in range(1, len(biglist)): if biglist[i][1]< smallest: smallest = biglist[i][1] smallest_index = i if biglist[i][1] > largest: largest = biglist[i][1] largest_index = i left_boundary_index = smallest_index right_boundary_index = smallest_index smallest_holder = smallest for k in range(smallest, largest+1): # list for holding values as we iterate through each row rowlist = [] #find all points in circle with this common y value for i in range(0, len(biglist)): if biglist[i][1] == (smallest_holder): rowlist.append(biglist[i]) smallest_x = rowlist[0][0] smallest_x_index = 0 largest_x = rowlist[0][0] largest_x_index = 0 #Find points in row that have largest and smallest x values for i in range(1, len(rowlist)): if rowlist[i][0]< smallest_x: smallest_x = rowlist[i][0] smallest_x_index = i if rowlist[i][0] > largest_x: largest_x = rowlist[i][0] largest_x_index = i # cycle through row and add all copy points counter = 0 for i in range(rowlist[smallest_x_index][0],rowlist[largest_x_index][0]): temp.x = rowlist[smallest_x_index][0] + counter temp.y = rowlist[smallest_x_index][1] #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) counter = counter + 1 rowlist = [] smallest_holder = smallest_holder + 1 del points[0] # remove unused location return points
def main( x, y, majA, minB ): temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] xC = majA yC = 0 quadrant = 2 half = 1 / 2 aSquared = pow( majA, 2 ) bSquared = pow( minB, 2 ) temp.x = xC temp.y = yC points.append( copy.deepcopy( temp ) ) accept1 = True accept2 = True #In region 2 while accept1: if ( aSquared * ( yC + 1 ) ) < ( bSquared * ( xC - half ) ): yC = yC + 1 ySquared = pow( yC, 2 ) #Find the next x and y values frac = ySquared / bSquared minusFrac = 1 - frac times = aSquared * minusFrac xC = math.sqrt( times ) xC = round( xC ) temp.x = xC temp.y = yC points.append( copy.deepcopy( temp ) ) if ( aSquared * ( yC + 1 ) ) >= ( bSquared * ( xC - half ) ): accept1 = False #In region 1 while accept2: xC = xC - 1 xSquared = pow( xC, 2 ) #Find the next x and y values frac = xSquared / aSquared minusFrac = 1 - frac times = bSquared * minusFrac yC = math.sqrt( times ) yC = round( yC ) temp.x = xC temp.y = yC points.append( copy.deepcopy( temp ) ) if xC <= 0: accept2 = False length = len( points ) #Find all other symetric points while quadrant <= 4: for c in range( 1, length ): if quadrant == 2: newVal = points[ c ] temp.x = -1 * newVal.x temp.y = newVal.y points.append( copy.deepcopy( temp ) ) elif quadrant == 3: newVal = points[ c ] temp.x = -1 * newVal.x temp.y = -1 * newVal.y points.append( copy.deepcopy( temp ) ) elif quadrant == 4: newVal = points[ c ] temp.x = newVal.x temp.y = -1 * newVal.y points.append( copy.deepcopy( temp ) ) else: print( 'There was an error' ) #end inner if-else statements #end c for loop quadrant = quadrant + 1 #end of while loop length = len( points ) for f in range( 1, length ): points[ f ].y = points[ f ].y + y points[ f ].x = points[ f ].x + x del points[ 0 ] return points
def main(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, x7, y7, x8, y8, x9, y9): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] fillpoints = [copy.deepcopy(one_color.struc)] del points[0] del fillpoints[0] #Get all the points in an edge line1 = [x1, y1, x2, y2] line2 = [x2, y2, x3, y3] line3 = [x3, y3, x4, y4] line4 = [x4, y4, x5, y5] line5 = [x5, y5, x6, y6] line6 = [x6, y6, x7, y7] line7 = [x7, y7, x8, y8] line8 = [x8, y8, x9, y9] line9 = [x9, y9, x1, y1] border = draw_polygon.main(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, x7, y7, x8, y8, x9, y9) length = len(border) #find the smallest and largest y values #will be used as the limit of scan line minY = border[0].y maxY = border[0].y for i in range(length): if border[i].y < minY: minY = border[i].y elif border[i].y > maxY: maxY = border[i].y #end of if-else statement #end of i for loop print('Found scan borders') print('minY = ', minY) print('maxY = ', maxY) #Find all the intersection points in the edges #with the scan line scan = minY + 1 while scan < maxY: point1 = scan_line.main(line1, scan) point2 = scan_line.main(line2, scan) point3 = scan_line.main(line3, scan) point4 = scan_line.main(line4, scan) point5 = scan_line.main(line5, scan) point6 = scan_line.main(line6, scan) point7 = scan_line.main(line7, scan) point8 = scan_line.main(line8, scan) point9 = scan_line.main(line9, scan) if len(point1) == 0: pass else: points = points + point1 if len(point2) == 0: pass else: points = points + point2 if len(point3) == 0: pass else: points = points + point3 if len(point4) == 0: pass else: points = points + point4 if len(point5) == 0: pass else: points = points + point5 if len(point6) == 0: pass else: points = points + point6 if len(point7) == 0: pass else: points = points + point7 if len(point8) == 0: pass else: points = points + point8 if len(point9) == 0: pass else: points = points + point9 #Begin of sort length = len(points) print(length) done = False head = 0 tail = 1 while done == True: check = 0 if check == length - 1: done = False if tail >= length: head = 0 tail = 1 if points[head].x > points[tail].x: temp = points[tail] points[tail] = points[head] points[head] = temp head = head + 1 tail = tail + 1 else: head = head + 1 tail = tail + 1 check = check + 1 #End of while loop #Get pairs of points that need to be filled head = 0 tail = 1 while head < length - 1: fill = draw_line.main(points[head].x, points[head].y, points[tail].x, points[tail].y) fillpoints = fillpoints + fill #end of i for loop head = head + 2 tail = tail + 2 del points[:] scan = scan + 1 #add border points return fillpoints
def main( x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, x7, y7, x8, y8, x9, y9 ): temp = one_color.struc() points = [ copy.deepcopy( one_color.struc ) ] fillpoints = [ copy.deepcopy( one_color.struc ) ] del points[ 0 ] del fillpoints[ 0 ] #Get all the points in an edge line1 = [ x1, y1, x2, y2 ] line2 = [ x2, y2, x3, y3 ] line3 = [ x3, y3, x4, y4 ] line4 = [ x4, y4, x5, y5 ] line5 = [ x5, y5, x6, y6 ] line6 = [ x6, y6, x7, y7 ] line7 = [ x7, y7, x8, y8 ] line8 = [ x8, y8, x9, y9 ] line9 = [ x9, y9, x1, y1 ] border = draw_polygon.main( x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, x6, y6, x7, y7, x8, y8, x9, y9 ) length = len( border ) #find the smallest and largest y values #will be used as the limit of scan line minY = border[ 0 ].y maxY = border[ 0 ].y for i in range( length ): if border[ i ].y < minY: minY = border[ i ].y elif border[ i ].y > maxY: maxY = border[ i ].y #end of if-else statement #end of i for loop print( 'Found scan borders' ) print( 'minY = ', minY ) print( 'maxY = ', maxY ) #Find all the intersection points in the edges #with the scan line scan = minY + 1 while scan < maxY: point1 = scan_line.main( line1, scan ) point2 = scan_line.main( line2, scan ) point3 = scan_line.main( line3, scan ) point4 = scan_line.main( line4, scan ) point5 = scan_line.main( line5, scan ) point6 = scan_line.main( line6, scan ) point7 = scan_line.main( line7, scan ) point8 = scan_line.main( line8, scan ) point9 = scan_line.main( line9, scan ) if len( point1 ) == 0: pass else: points = points + point1 if len( point2 ) == 0: pass else: points = points + point2 if len( point3 ) == 0: pass else: points = points + point3 if len( point4 ) == 0: pass else: points = points + point4 if len( point5 ) == 0: pass else: points = points + point5 if len( point6 ) == 0: pass else: points = points + point6 if len( point7 ) == 0: pass else: points = points + point7 if len( point8 ) == 0: pass else: points = points + point8 if len( point9 ) == 0: pass else: points = points + point9 #Begin of sort length = len( points ) print( length ) done = False head = 0 tail = 1 while done == True: check = 0 if check == length - 1: done = False if tail >= length: head = 0 tail = 1 if points[ head ].x > points[ tail ].x: temp = points[ tail ] points[ tail ] = points[ head ] points[ head ] = temp head = head + 1 tail = tail + 1 else: head = head + 1 tail = tail + 1 check = check + 1 #End of while loop #Get pairs of points that need to be filled head = 0 tail = 1 while head < length - 1: fill = draw_line.main( points[ head ].x, points[ head ].y, points[ tail ].x, points[ tail ].y ) fillpoints = fillpoints + fill #end of i for loop head = head + 2 tail = tail + 2 del points[ : ] scan = scan + 1 #add border points return fillpoints
def circle(radius, center_x, center_y): biglist = [] #data structure to hold points temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #initialize starting point to (r,0) temp.x = radius temp.y = 0 #add points to temporary data structure biglist.append([temp.x, temp.y]) biglist.append([temp.y, temp.x]) biglist.append([-(temp.x), temp.y]) biglist.append([temp.y, -(temp.x)]) while True: #compute next y location for the first octant temp.y = temp.y + 1 #compute the corresponding x value for y + 1 using Eq. 2.6 temp.x = math.sqrt((pow(radius, 2.0)) - (pow(temp.y, 2.0))) #Round to the nearest integer value temp.x = int(round(temp.x)) #Check to see if points are still in first octant if temp.x == temp.y: #compute other points on the circle by symmetry #Don't compute duplicate coordinates biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) else: #compute other points on the circle by symmetry biglist.append([temp.x, temp.y]) biglist.append([temp.y, temp.x]) biglist.append([-(temp.y), temp.x]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([-(temp.y), -(temp.x)]) biglist.append([temp.y, -(temp.x)]) biglist.append([temp.x, -(temp.y)]) if temp.x <= temp.y: break #add center point to all points for i in range(0, len(biglist)): temp.x = biglist[i][0] + center_x temp.y = biglist[i][1] + center_y #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) del points[0] # remove unused location return points
def circle(radius, center_x, center_y): biglist = [] #data structure to hold points temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #initialize starting point to (r,0) temp.x = radius temp.y = 0 #add points to temporary data structure biglist.append([temp.x, temp.y]) biglist.append([temp.y, temp.x]) biglist.append([-(temp.x), temp.y]) biglist.append([temp.y, -(temp.x)]) while True: #compute next y location for the first octant temp.y = temp.y + 1 #compute the corresponding x value for y + 1 using Eq. 2.6 temp.x = math.sqrt((pow(radius, 2.0)) - (pow(temp.y, 2.0))) #Round to the nearest integer value temp.x = int(round(temp.x)) #Check to see if points are still in first octant if temp.x == temp.y: #compute other points on the circle by symmetry #Don't compute duplicate coordinates biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) else: #compute other points on the circle by symmetry biglist.append([temp.x, temp.y]) biglist.append([temp.y, temp.x]) biglist.append([-(temp.y), temp.x]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([-(temp.y), -(temp.x)]) biglist.append([temp.y, -(temp.x)]) biglist.append([temp.x, -(temp.y)]) if temp.x <= temp.y: break #add center point to all points for i in range(0, len(biglist)): temp.x = biglist[i][0] + center_x temp.y = biglist[i][1] + center_y biglist[i][0] = biglist[i][0] + center_x biglist[i][1] = biglist[i][1] + center_y #add updated/finalized points to data structure #points.append(copy.deepcopy(temp)) smallest = biglist[0][1] smallest_index = 0 largest = biglist[0][1] largest_index = 0 #Find minimum and maximum y values of the circle and their indexes for i in range(1, len(biglist)): if biglist[i][1]< smallest: smallest = biglist[i][1] smallest_index = i if biglist[i][1] > largest: largest = biglist[i][1] largest_index = i left_boundary_index = smallest_index right_boundary_index = smallest_index smallest_holder = smallest for k in range(smallest, largest+1): # list for holding values as we iterate through each row rowlist = [] #find all points in circle with this common y value for i in range(0, len(biglist)): if biglist[i][1] == (smallest_holder): rowlist.append(biglist[i]) smallest_x = rowlist[0][0] smallest_x_index = 0 largest_x = rowlist[0][0] largest_x_index = 0 #Find points in rowlist that have largest and smallest x values for i in range(1, len(rowlist)): if rowlist[i][0]< smallest_x: smallest_x = rowlist[i][0] smallest_x_index = i if rowlist[i][0] > largest_x: largest_x = rowlist[i][0] largest_x_index = i # cycle through row and add all copy points counter = 0 for i in range(rowlist[smallest_x_index][0],rowlist[largest_x_index][0]): temp.x = rowlist[smallest_x_index][0] + counter temp.y = rowlist[smallest_x_index][1] #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) counter = counter + 1 rowlist = [] smallest_holder = smallest_holder + 1 del points[0] # remove unused location return points
def main(x, y, majA, minB): temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] xC = majA yC = 0 quadrant = 2 half = 1 / 2 aSquared = pow(majA, 2) bSquared = pow(minB, 2) temp.x = xC temp.y = yC points.append(copy.deepcopy(temp)) accept1 = True accept2 = True #In region 2 while accept1: if (aSquared * (yC + 1)) < (bSquared * (xC - half)): yC = yC + 1 ySquared = pow(yC, 2) #Find the next x and y values frac = ySquared / bSquared minusFrac = 1 - frac times = aSquared * minusFrac xC = math.sqrt(times) xC = round(xC) temp.x = xC temp.y = yC points.append(copy.deepcopy(temp)) if (aSquared * (yC + 1)) >= (bSquared * (xC - half)): accept1 = False #In region 1 while accept2: xC = xC - 1 xSquared = pow(xC, 2) #Find the next x and y values frac = xSquared / aSquared minusFrac = 1 - frac times = bSquared * minusFrac yC = math.sqrt(times) yC = round(yC) temp.x = xC temp.y = yC points.append(copy.deepcopy(temp)) if xC <= 0: accept2 = False length = len(points) #Find all other symetric points while quadrant <= 4: for c in range(1, length): if quadrant == 2: newVal = points[c] temp.x = -1 * newVal.x temp.y = newVal.y points.append(copy.deepcopy(temp)) elif quadrant == 3: newVal = points[c] temp.x = -1 * newVal.x temp.y = -1 * newVal.y points.append(copy.deepcopy(temp)) elif quadrant == 4: newVal = points[c] temp.x = newVal.x temp.y = -1 * newVal.y points.append(copy.deepcopy(temp)) else: print('There was an error') #end inner if-else statements #end c for loop quadrant = quadrant + 1 #end of while loop length = len(points) for f in range(1, length): points[f].y = points[f].y + y points[f].x = points[f].x + x del points[0] return points
def ellipse(a, b, center_x, center_y): # a == major axis # b == minor axis biglist = [] #data structure to hold points temp = one_color.struc() points = [copy.deepcopy(one_color.struc)] #initialize starting point to (a,0) temp.x = a temp.y = 0 biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) while True: #check to see if in region 2 if ((pow(a, 2.0)) * (temp.y + 1)) < ((pow(b, 2.0)) * (temp.x - 0.5)): #compute next y location for region 2 temp.y = temp.y + 1 #compute the corresponding x value for y + 1 using Eq. 2.8 temp.x = math.sqrt( (pow(a, 2.0)) * (1 - ((pow(temp.y, 2.0)) / (pow(b, 2.0))))) #Round to the nearest integer value temp.x = int(round(temp.x)) #compute other points on the circle by symmetry biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) #check if still in region 2, if not move on if ((pow(a, 2.0)) * (temp.y + 1)) >= ((pow(b, 2.0)) * (temp.x - .5)): break #if not in region 2, move on to region 1 else: break while True: #compute next x location for region 1 temp.x = temp.x - 1 #compute the y value for x - 1 using Eq. 2.9 temp.y = math.sqrt( (pow(b, 2.0)) * (1 - ((pow(temp.x, 2.0)) / (pow(a, 2.0))))) #Round to the nearest integer temp.y = int(round(temp.y)) #if x > 0, keep looping through looking to compute y values if temp.x == 0: biglist.append([temp.x, temp.y]) biglist.append([temp.x, -(temp.y)]) else: biglist.append([temp.x, temp.y]) biglist.append([-(temp.x), temp.y]) biglist.append([-(temp.x), -(temp.y)]) biglist.append([temp.x, -(temp.y)]) if temp.x <= 0: break #add center point to all points for i in range(0, len(biglist)): temp.x = biglist[i][0] + center_x temp.y = biglist[i][1] + center_y biglist[i][0] = biglist[i][0] + center_x biglist[i][1] = biglist[i][1] + center_y #add updated/finalized points to data structure points.append(copy.deepcopy(temp)) del points[0] # remove unused location return points