def rotate_coordinatearray_2d(xylst, angle, pivot): '''2D rotation of list of coordinate pairs (CoordinateArray). - `xylst` list of (x, y) coordinate pairs. - `angle` is the angle of rotation in radians. - `pivot` the point around which to rotate `xy`. Returns a CoordinateArray. ''' result = CoordinateArray( ) for xy in xylst: r = rotate_coordinate_2d(xy, angle, pivot) result.append(r) return result
result.append((coord_pair, 1)) else: result.append((coord_pair, int(round(segs)))) return result divs = units_per_path_segment(coords, interpolation_unit) result = [] for cp, n in divs: newcoords = [interpolate_linear(cp[0], cp[1], float(i) / n) for i in range(n)] result.extend(newcoords) return Path(result) ## demo if __name__ == "__main__": from chiplotle import * import random coords = CoordinateArray([random.randint(0, 1000) for i in range(10)]) # coords = CoordinateArray([0, 0, 300, 0, 300, 300, 0, 300, 0, 0]) p = path_linear(coords, 100) circs = [] for coord in p.points: c = circle(10, 8) offset(c, coord) circs.append(c) io.view(group([p] + circs))
def _preformat_points(self): '''Points (coordinates) ready for formatting (conversion to HPGL).''' coords = self.points[:] coords.append(coords[0]) return CoordinateArray(coords)
def fset(self, arg): self._coords = CoordinateArray(arg)
def test_shapes_group_points_03(): '''A non-flat Group has a CoordinateArray.''' g = Group([Path([(1, 2), (3, 4)]), Path([(4, 2), (4, 2)])]) t = Group([g, Path([(100, 200)])]) assert t.points == CoordinateArray([(1, 2), (3, 4), (4, 2), (4, 2), (100, 200)])
def test_shapes_group_points_01(): '''An empty Group has an empty CoordinateArray.''' t = Group() assert t.points == CoordinateArray([])
for coord in coord_array.difference: ratio = coord.magnitude / total_length c = rounder.round(count * ratio) r = split_vector_equidistantly(coord, c) r = r.difference result.extend(r) result = CoordinateArray(result).cumsum + coord_array[0] assert len(result) == count + 1 return result class Rounder(object): '''Hack class to keep track of residues. Come up with a good structural / rational solution. ''' def __init__(self): self.residue = 0 def round(self, n): if abs(self.residue) >= 0.5: n = n - self.residue self.residue = 0 rn = int(round(n)) self.residue += rn - n return rn if __name__ == '__main__': ca = CoordinateArray([(20, 0), (20, 500), (20, 1000)]) print split_coordinatearray_proportionally(ca, 8)
def test_shapes_group_points_02(): '''A flat Group has a CoordinateArray.''' t = Group([Path([(1, 2), (3, 4)]), Path([(4, 2), (4, 2)])]) assert t.points == CoordinateArray([(1, 2), (3, 4), (4, 2), (4, 2)])
def points(self, arg): self._points = CoordinateArray(arg)
def __init__(self, points): _Shape.__init__(self) self.points = CoordinateArray(points)
def __sub__(self, arg): return self + (-arg) def __isub__(self, arg): self.points = self.points - arg return self def __rsub__(self, arg): return -(self - arg) def __eq__(self, arg): try: return self.points == arg.points except AttributeError: return False def __ne__(self, arg): return not (self == arg) def __neg__(self): return Path(-self.points) ## RUN DEMO CODE if __name__ == "__main__": from chiplotle.tools import io p = Path(CoordinateArray([(1, 2), (4, 6), (0, 2), (5, 1)]) * 1000) io.view(p)
def _assert_transform_changes_coords(shape, transform, trans_args): points_before = CoordinateArray(shape.points) transform(shape, *trans_args) points_after = CoordinateArray(shape.points) assert points_before != points_after
def _assert_transform_preserves_diff(shape, transform, trans_args): points_before = CoordinateArray(shape.points).difference transform(shape, *trans_args) points_after = CoordinateArray(shape.points).difference assert points_before == points_after