FreehandCutPlotter render question

[jkissi]

Hi Marco!
As I am sure you remember, I am attempting to implement a polyhedral cutter using your freehandcutter tool as a base. I am making good progress but I am running into a problem, where I cannot seem to remove from the renderer the lines that have been made in the process of creating the polyhedral shape. I have tried to remove those Line objects from the self.actors list, but that doesn't seem to update the renderer, so I am a little perplexed as to how to do this. I am trying to preserve all the original functionality so, I want to be able to delete the splines, reset the renderer etc. Also, the software I am making has dependencies that require I am on a lower version of python 3, thats why I am not using the modification you made in our previous conversation!

I have modified the cutter such that: it starts in the original freehand mode; you press 'e' to enter straight line freehand mode and you press 'v' to go back into freehand mode. Once in straight line freehand mode, you create the lines by right clicking to start the line and right clicking again to stop it.

My code is below:

import vedo
from vedo import Points, fitPlane, Ribbon, Cube, mag, Spline, Line
from vedo.applications import FreeHandCutPlotter
import numpy as np
      
      
      
def runtest():
    class squareCutPlotter(vedo.applications.FreeHandCutPlotter):
        """Test for the creation of a class extension for cutting point clouds
        """
    
        def __init__(self, mesh, **options):
            super().__init__(mesh, **options)
    
            self.rect = None
            self.poly = None
            self.rectd = False
            self.ployd = False
            self.strfreed = False # switch to enter straight line freehand mode
            self.line_counter = 0
            self.strfre = None
            self.npcl, self.opcl = None, None
            self.sfidx_curr, self.sfidx_prev = None, None
            self.new_arr = []
    
    
        def newFunction(self, *args, **kwargs):
            """Function that is new!!!
            """
            #print(f"Thisis the list:{self.__class__.__dict__}")
            self.start(*args, **kwargs)
    
    
        def getPointsCallback(self, evt):
            """Call back to get the points under the cursor
            """
            if not evt.actor:
                return
            print(f"These are the cpoints: {self.cpoints}")
    
    
    
        def getSplineValsCallback(self, evt):
            """Call back to get the points in the spline
            """
    
            tol = self.mesh.diagonalSize()/2            # size of ribbon (not shown)
            pts = self.spline.points()
            n = fitPlane(pts, signed=True).normal       # compute normal vector to points
            rb = Ribbon(pts - tol*n, pts + tol*n, closed=True)
            #self.mesh.cutWithMesh(rb, invert=inv)       # CUT
    
    
        def getSplineValsCallback2(self, evt):
            """Test of key press callback
            """
    
            if evt.keyPressed.lower() == 'z' and self.spline: # Cut mesh with a ribbon-like surface
                inv = False
                if evt.keyPressed == 'Z':
                    inv = True
                self.txt2d.background('red8').text("  ... working ...  ")
                self.render()
                self.mesh_prev = self.mesh.clone()
                tol = self.mesh.diagonalSize()/2            # size of ribbon (not shown)
                if self.splined or self.strfreed:
                    pts = self.spline.points()
                elif self.rectd:
                    pts = self.rect.points()
                elif self.polyd:
                    pts = self.poly.points()
    
                n = fitPlane(pts, signed=True).normal       # compute normal vector to points
                rb = Ribbon(pts - tol*n, pts + tol*n, closed=True)
    
                self.npcl = rb.insidePoints(self.mesh).c([255, 215, 0], 0.7).ps(10)
                self.opcl = rb.insidePoints(self.mesh, invert=True).ps(10)
                self.remove(self.mesh).add([self.npcl, self.opcl])
                self.render()
                self.mesh = self.mesh_prev
                #self.mesh.cutWithMesh(rb, 0.5), invert=inv)       # CUT
    
    
                self.txt2d.text(self.msg)                   # put back original message
                if self.drawmode:
                    self._onRightClick(evt)                 # toggle mode to normal
                else:
                    self.txt2d.background(self.color, self.alpha)
    
                if self.splined:
                    self.remove([self.spline, self.points, self.jline, self.topline]).render()
                    self.cpoints, self.points, self.spline = [], None, None
                    self.top_pts, self.topline = [], None
                elif self.strfreed:
                    self.remove([self.spline, self.points, self.jline, self.topline]).render()
                    self.cpoints, self.points, self.spline = [], None, None
                    self.top_pts, self.topline = [], None
                elif self.rectd:
                    self.remove([self.rect]).render()
                    self.cpoints = []
                elif self.polyd:
                    self.remove([self.poly]).render()
                    self.cpoints = []
    
    
            elif evt.keyPressed == 'L':
                self.txt2d.background('red8')
                self.txt2d.text(" ... removing smaller ... \n ... parts of the mesh ... ")
                self.render()
                self.remove(self.mesh)
                self.mesh_prev = self.mesh
                mcut = self.mesh.extractLargestRegion()
                mcut.filename = self.mesh.filename          # copy over various properties
                mcut.name = self.mesh.name
                mcut.scalarbar= self.mesh.scalarbar
                mcut.info = self.mesh.info
                self.mesh = mcut                            # discard old mesh by overwriting it
                self.txt2d.text(self.msg).background(self.color)   # put back original message
                self.add(mcut)
    
            elif evt.keyPressed == 'u':                     # Undo last action
                if self.drawmode:
                    self._onRightClick(evt)                 # toggle mode to normal
                else:
                    self.txt2d.background(self.color, self.alpha)
    
                if self.splined:
                    self.remove([self.mesh, self.spline, self.jline, self.points, self.topline, self.npcl, self.opcl])
                elif self.strfreed:
                    self.remove([self.mesh, self.spline, self.jline, self.points, self.topline, self.npcl, self.opcl])
                elif self.rectd:
                    self.remove([self.rect])
                    self.cpoints = []
                elif self.polyd:
                    self.remove([self.poly])
                    self.cpoints = []
    
                self.mesh = self.mesh_prev
    
                if self.splined:
                    self.cpoints, self.points, self.spline = [], None, None
                    self.top_pts, self.topline = [], None
                elif self.strfreed:
                    self.cpoints, self.points, self.spline = [], None, None
                    self.top_pts, self.topline = [], None
                elif self.rectd:
                    self.remove([self.rect]).render()
                    self.cpoints = []
                elif self.polyd:
                    self.remove([self.poly]).render()
                    self.cpoints = []
    
                self.add(self.mesh)
    
            elif evt.keyPressed == 'c' or evt.keyPressed == 'Delete':
                print("I should see this")
                # clear all points
                if self.splined:
                    self.remove([self.spline, self.points, self.jline, self.topline]).render()
                    self.cpoints, self.points, self.spline = [], None, None
                    self.top_pts, self.topline = [], None
                elif self.strfreed:
                    self.remove([self.spline, self.points, self.jline, self.topline]).render()
                    self.cpoints, self.points, self.spline = [], None, None
                    self.top_pts, self.topline = [], None
                elif self.rectd:
                    self.remove(self.rect).render()
                    self.cpoints = []
                elif self.polyd:
                    self.remove(self.poly).render()
                    self.cpoints = []
    
    
            elif evt.keyPressed == 'r': # reset camera and axes
                try:
                    self.remove(self.axes_instances[0])
                    self.axes_instances[0] = None
                    self.addGlobalAxes(axtype=1, c=None)
                    self.renderer.ResetCamera()
                    self.interactor.Render()
                except:
                    pass
    
            elif evt.keyPressed == 's':
                if self.mesh.filename:
                    fname = os.path.basename(self.mesh.filename)
                    fname, extension = os.path.splitext(fname)
                    fname = fname.replace("_edited","")
                    fname = f"{fname}_edited{extension}"
                else:
                    fname="mesh_edited.vtk"
                self.write(fname)
    
            # rectangle selection mode
            elif evt.keyPressed == 'g':
                self.rectd = True
                self.splined = False
                self.polyd = False
                self.strfreed = False
                self.txt2d.background('red8')
                self.txt2d.text(f"cutting mode is rect: {self.rectd}\n"
                                f"cutting mode is poly: {self.polyd}\n"
                                f"cutting mode is freehand: {self.splined}\n"
                                f"cutting mode is str freehand: {self.strfreed}\n")
                self.render()
    
    
            # polygon selection mode
            elif evt.keyPressed == 'i':
                self.rectd = False
                self.splined = False
                self.polyd = True
                self.strfreed = False
                self.txt2d.background('red8')
                self.txt2d.text(f"cutting mode is rect: {self.rectd}\n"
                                f"cutting mode is poly: {self.polyd}\n"
                                f"cutting mode is freehand: {self.splined}\n"
                                f"cutting mode is str freehand: {self.strfreed}\n")
                self.render()
    
            # freehand selection mode
            elif evt.keyPressed == 'v':
                self.rectd = False
                self.splined = True
                self.polyd = False
                self.strfreed = False
                self.txt2d.background('red8')
                self.txt2d.text(f"cutting mode is rect: {self.rectd}\n"
                                f"cutting mode is poly: {self.polyd}\n"
                                f"cutting mode is freehand: {self.splined}\n"
                                f"cutting mode is str freehand: {self.strfreed}\n")
                self.render()
            # straight freehand selection mode
            elif evt.keyPressed == 'e':
                self.rectd = False
                self.splined = False
                self.polyd = False
                self.strfreed = True
                self.txt2d.background('red8')
                self.txt2d.text(f"cutting mode is rect: {self.rectd}\n"
                                f"cutting mode is poly: {self.polyd}\n"
                                f"cutting mode is freehand: {self.splined}\n"
                                f"cutting mode is str freehand: {self.strfreed}\n")
                self.render()
    
    
        def testOnRightClick(self, evt):
            self.drawmode = not self.drawmode # toggle mode
    
            if self.drawmode:
                self.txt2d.background(self.linecolor, self.alpha)
    
                if self.strfreed:
                    self.sfidx_curr = len(self.cpoints)
                    if self.sfidx_curr > 0:
                        self.new_arr.append(self.cpoints[self.sfidx_curr-1])
                    self.cpoints = []
                    # deep copy the list, dont simply create a new pointer to the old list
                    self.cpoints = self.new_arr.copy()
                    self.line_counter += 1
    
            else:
                self.txt2d.background(self.color, self.alpha)
                if self.strfreed:
                    self.cpoints.append(self.cpt)
                print(f"This is toast...{len(self.cpoints)}")
                if len(self.cpoints) >= 2:
    
                    if self.splined or self.strfreed: # show the spline closed
                        if self.splined:
                            self.remove([self.spline, self.jline])
                            self.spline = Spline(self.cpoints, closed=True, res=len(self.cpoints)*4)
                        elif self.strfreed:
                            if len(self.cpoints) < 2:
                                return
                            else:
                                self.spline = Line(self.cpoints[-2], self.cpoints[-1], lw=1, c=self.linecolor).pickable(0)
                                # TODO: THIS IS WHERE I SET THE NAME ATTRIBUTE
                                # I tried naming each line created for easy removal but
                                # name appears to be reset once Line object is placed in  self.actors
                                self.spline.name=f"spline_{self.line_counter}"
    
                            if len(self.cpoints) > 2:
                                # if the last and second to last points in cpoints are too close together, remove the last point
                                if mag(self.cpoints[-2] - self.cpoints[-1]) < self.mesh.diagonalSize()*self.tol:
                                    self.cpoints.pop()
    
                                 spline = self.generateSpline()
                                # TODO: THIS IS THE IMPORTANT PART
                                if spline is not None:
                                    for i in np.arange(0, self.line_counter):
                                        self.remove(f"spline_{self.line_counter}").render()

                                    self.spline = spline
    
                        self.spline.lw(self.linewidth).c(self.linecolor).pickable(False)
                        self.add(self.spline)
                    else:
                        self.spline = Line(self.cpoints, closed=True)
    
    
        def testoOnMouseMove(self, evt):
            if self.drawmode:
                if self.splined:
                    self.cpt = self.computeWorldPosition(evt.picked2d) # make this 2d-screen point 3d
                    if self.cpoints and mag(self.cpt - self.cpoints[-1]) < self.mesh.diagonalSize()*self.tol:
                        return  # new point is too close to the last one. skip
                    self.cpoints.append(self.cpt)
                elif self.strfreed:
                    self.cpt = self.computeWorldPosition(evt.picked2d) # make this 2d-screen point 3d
                    if self.cpoints and mag(self.cpt - self.cpoints[-1]) < self.mesh.diagonalSize()*self.tol:
                        return  # new point is too close to the last one. skip
                    if self.strfreed:
                        if not self.cpoints:
                            self.cpoints.append(self.cpt)
                            self.new_arr.append(self.cpt)
                            self.sfidx_prev = len(self.new_arr)
                            self.sfidx_curr = len(self.new_arr)
                        else:
                            self.cpoints.append(self.cpt)
    
                if self.splined or self.strfreed:
                    if len(self.cpoints) > 2:
                        # spline: points making up the line drawn by the mouse
                        # jline: small line connecting the first point and the end point (during drawing)
                        # topline: ?
                        self.remove([self.points, self.spline, self.jline, self.topline])
    
                        if self.splined:
                            self.points = Points(self.cpoints, r=self.linewidth).c(self.pointcolor).pickable(0)
                            self.spline = Spline(self.cpoints, res=len(self.cpoints)*4) # not closed here
                        elif self.strfreed:
                            # if len(self.new_arr) > 2:
                            self.spline = Line(self.new_arr[-1], self.cpoints[-1], lw=1, c=self.linecolor).pickable(0)
                            #self.points = Points(self.cpoints, r=self.linewidth).c(self.pointcolor).pickable(0)
                            #self.spline = Spline(self.cpoints)#, res=len(self.cpoints)*4)
                        else:
                            self.spline = Line(self.cpoints)
    
                        if evt.actor:
                            self.top_pts.append(evt.picked3d)
                            # self.topline = Line(self.top_pts)
                            # self.topline.lw(self.linewidth-1).c(self.linecolor).pickable(False)
                            self.topline = Points(self.top_pts, r=self.linewidth)
                            self.topline.c(self.linecolor).pickable(False)
    
                        self.spline.lw(self.linewidth).c(self.linecolor).pickable(False)
                        self.txt2d.background(self.linecolor)
                        self.jline = Line(self.cpoints[0], self.cpoints[-1], lw=1, c=self.linecolor).pickable(0)
                        self.add([self.points, self.spline, self.jline, self.topline])
    
    
        def generateSpline(self):
            """Helper function to generate closed spline from a series of connected lines
            """
    
            # make sure only the most important points are retained
            if len(self.cpoints) > len(self.new_arr):
                self.sfidx_curr = len(self.cpoints)
    
                if self.sfidx_curr > 0:
                    self.new_arr.append(self.cpoints[self.sfidx_curr-1])
                self.cpoints = []
                # deep copy the list, dont simply create a new pointer to the old list
                self.cpoints = self.new_arr.copy()
    
            # if the first and last points in cpoints are close together, create a closed spline
            if self.cpoints and mag(self.cpoints[0] - self.cpoints[-1]) < self.mesh.diagonalSize()*self.tol:
                # get the unique values
                unique, counts = np.unique(self.cpoints, axis=0, return_counts=True)
                self.cpoints = unique
                spline = Line(self.cpoints, closed=True, res=1)
                print(f"This is the final number of cpoints: {len(self.cpoints)}")
                # try ConvexHull() insted of Line
    
                return spline
            else:
                return
    
    
    vedo.settings.useParallelProjection = True  # to avoid perspective artifacts
    pts = np.random.randn(20, 3)
    pts = Points(pts).ps(8)
    pts.name = "My Gaussian"
    
    cube = Cube().x(2)
    
    plt = squareCutPlotter(pts).addHoverLegend()
    plt.removeCallback(plt.idkeypress)
    plt.removeCallback(plt.idrightclck)
    plt.removeCallback(plt.idmousemove)
    plt.addCallback('RightButtonPress', plt.testOnRightClick)
    plt.addCallback('KeyPress', plt.getSplineValsCallback2, priority=100)
    plt.addCallback('MouseMove', plt.testoOnMouseMove)
    plt.newFunction(pts, cube, bg2='lightblue',axes=1)
    
    print('Done')
    print('Done')

if __name__ == "__main__":
    run_test()

Please forgive the messy nature, it is still in the prototyping stage, but you should be able to copy paste and run it. I am using an anaconda environment running python 3.8.12, if you need that info. As always, thanks very much!!

j

[marcomusy]

It's a bit difficult to dig into your code :)
The python version should not matter so much, I guess you are using the vedo-dev version ?
About removing objects, the simplest way is to give them a name
mymesh.name = "Karen"
and then
plt.remove("Karen").render()

have you tried that already?

[jkissi]

Hi marco,
no i am using the version packaged with conda in the conda-forge channel, version: 2021.0.6 (pyhd8ed1ab_0). I did not realise thats the way the name attribute worked with remove. I will try that and get back to you....

[jkissi]

Hi Marco,
Unfortunately, the above suggestion does not seem to clear the renderer of the Line objects created.

I modified the code to make it more simple to run (I am running it in debug mode in Spyder), this is how I am prototyping the code. Should be runable by just calling the <filename>.py. Most of the code is just so it will run self contained. The problem I dealing with is centered in the function testOnRightClick(). I have relabelled lines I am confused about with comments in caps.

This is essentially heavily based on your original code from the FreeHandCutPlotter class. I am very confused as to how something can be added to the renderer that isn't removed by pressing 'c' (as per your original code). do you have any ideas how that can be?

[jkissi]

p.s. self.strfreed is the switch I activate to enter the straight line cutter mode, so in general, where you see this is where this code for this mode is situated....

[marcomusy]

Hi
it seems to me that the problem is in the logic you are using... In this block

                        elif self.strfreed:
                            if len(self.cpoints) < 2:
                                return
                            else:
                                self.spline = Line(self.cpoints[-2], self.cpoints[-1], lw=1, c=self.linecolor).pickable(0)
                                # TODO: THIS IS WHERE I SET THE NAME ATTRIBUTE
                                # I tried naming each line created for easy removal but
                                # name appears to be reset once Line object is placed in  self.actors
                                self.spline.name=f"spline_{self.line_counter}"

                            if len(self.cpoints) > 2:
                                # if the last and second to last points in cpoints are too close together, remove the last point
                                if mag(self.cpoints[-2] - self.cpoints[-1]) < self.mesh.diagonalSize()*self.tol:
                                    self.cpoints.pop()

                                spline = self.generateSpline()
                                # TODO: THIS IS THE IMPORTANT PART
                                if spline is not None:
                                    for i in np.arange(0, self.line_counter):
                                        self.remove(f"spline_{self.line_counter}").render()

you are giving it a name .. but you never add it to the rendering scene, yet you are trying to remove just after ..
It may help you printing the object names your placing in the scene, names are never reset!

[jkissi]

Hi!
I the point you made above is a good point. I will fix that, but I found the problem to be something else:
using the name string directly self.remove("Line").render() did not work for me but using self.remove(self.actors[3].name).render() (self.actors[3].name = "Line") did remove the line in question from the renderer. Using a simple loop I have this working now.

Do you have any idea why there would be such a discrepancy? Both are functionally equivalent, are they not?
As usual, thank you so much for your help
j

[marcomusy]

uhmm I don't understand that! If
self.actors[3].name = "Line"
then calling
self.remove("Line") or self.remove(self.actors[3].name)
should be exactly the same.. cannot be different in python.. maybe you can check type(self.actors[3].name) to be a string?

PS: for performance you may want to call self.render() outside of the loop

[jkissi]

thanks for the heads up, I will try the performance trick. here is the output from terminal for the other point.

ipdb> self.actors
[(Text2D)00000207E20B0A00, (Points)00000207E20B0640, (Box)00000207DB7C6CA0, (Line)00000207E180C220, (Line)00000207E1810340, (Line)00000207E180C1C0, (Line)00000207E180C3A0, (Line)00000207E180C400]

ipdb> self.actors[3].name
'Line'

ipdb> type(self.actors[3].name)
<class 'str'>

Seems like it is a string....

[marcomusy]

uhm maybe it's only removing the first (or the last) "Line"?