In my app, a shape is drawn consisting of many points, which are drawn with a ui.Path, somewhat like this:

```
for i in range(1,len(self.points)):
x1 = self.points[i].x
y1 = self.points[i].y
x2 = self.points[i + 1].x
y2 = self.points[i + 1].y
self.path.move_to(x1, y1)
self.path.line_to(x2, y2)
self.set_needs_display()
```

After this is done I would like to be able to draw on top of that shape with a different color and only on that shape. I basically want to be able to recolor parts of the path.

I was thinking that using add_clip() could be used on the path that drew the shape, constricting new drawing operations to the shape. Unfortunately I have not been able to make add_clip work.

Does my approach make sense? If so, where would I use add_clip?

]]>https://github.com/HenningTm/drawing_touchpad

The .xlsx file in the repository contains the point coordinates for the shape and is redrawn in lines 474-489. ]]>

`draw`

, at the point you change the color and start drawing the new segments.
maybe post a gist with your code?

I am assuming you are starting frim the sketch example?

]]>ui.set_blend_mode(mode)

with ui.BLEND_COLOR ]]>

Any ideas how else I might accomplish this?

Here is the code of my attempt with the numpy array:

```
def touch_began(self,touch):
self.x1, self.y1 = touch.location
x = int(self.x1)
y = int(self.y1)
x = x * 2
y = y * 2
if pix[y,x] < 255:
self.drawDot(touch.location,self.dotSize)
self.check_area(touch.location, 15)
return
def check_area(self, t, size): # Checks area around touch for dark pixels and paints them red
self.x1, self.y1 = t
x = int(self.x1)
y = int(self.y1)
x = x * 2
y = y * 2
ptsx = []
ptsy = []
thresh = 120
for xx in range(size):
print('x: '+str(xx))
for yy in range(size):
print('y: '+str(yy))
xn = 0
yn = 0
if pix[y + yy, x + xx] < thresh:
xn = (x + xx) * 0.5
yn = (y + yy) * 0.5
# print(xn)
xn = math.ceil(xn)
# print(xn)
yn = math.ceil(yn)
ptsx.append(xn)
ptsy.append(yn)
if pix[y - yy, x - xx] < thresh:
xn = (x - xx) * 0.5
yn = (y - yy) * 0.5
xn = math.ceil(xn)
yn = math.ceil(yn)
ptsx.append(xn)
ptsy.append(yn)
if pix[y + yy, x - xx] < thresh:
xn = (x - xx) * 0.5
yn = (y + yy) * 0.5
xn = math.ceil(xn)
yn = math.ceil(yn)
ptsx.append(xn)
ptsy.append(yn)
if pix[y - yy, x + xx] < thresh:
xn = (x + xx) * 0.5
yn = (y - yy) * 0.5
xn = math.ceil(xn)
yn = math.ceil(yn)
# self.drawDotCoords(xn,yn,self.dotSize)
ptsx.append(xn)
ptsy.append(yn)
# if xn != 0:
# ptsx.append(xn)
# ptsy.append(yn)
if len(ptsx) > 0:
self.drawDotCoords(ptsx,ptsy,self.dotSize) # Draws a one-pixel dot on each surrounding dark pixel
```

]]>Path.hit_test(x,y) checks only the object bounds, not if a line is hit.

So if you are working only with the coordinates, you have to do a lot of calculations to check for a real hit. ]]>