How to cut from object

ado130 · 29 Sept 2016, 13:33

	active_edges = model.active_entities.grep(Sketchup;;Edge)
	group = Sketchup.active_model.active_entities.add_group()
	gents = group.entities
	edges = gents.add_circle(center, dir, notchRadius[0]) 
	first = edges[0].faces[0]
	new_edges = model.active_entities.grep(Sketchup;;Edge) - active_edges

Now, should I delete those in new_edges which have no faces, but I'm not sure, how to find them. And you said, thath I need to check its edges for their faces , what do you mean there?

Thanks

TIG · 29 Sept 2016, 14:30

After making the array of edges before you start [active_edges]...
Then after adding your new edges etc...
new_edges = model.active_entities.grep(Sketchup::Edge) - active_edges new_edges.each{|edge| edge.erase! unless edge.faces[0] }

There is a more efficient way, collecting then deleting them at the end but since you'll only have a few to erase it's probably not worth it...
But FYI here it is...
new_edges = model.active_entities.grep(Sketchup::Edge) - active_edges togos = [] ### empty array new_edges.each{|edge| togos << edge unless edge.faces[0] } model.active_entities.erase_entities(togos) if togos[0]

ado130 · 29 Sept 2016, 19:48

So, is this correct? Now just pushpull the new face (which?) and it should be done.

		active_edges = model.active_entities.grep(Sketchup;;Edge)
		group = Sketchup.active_model.active_entities.add_group()
		gents = group.entities
		edges = gents.add_circle(center, dir, radius[i])
		first = edges[0].faces[0]
		puts first
		new_edges = model.active_entities.grep(Sketchup;;Edge) - active_edges
		togos = [] ### empty array
		new_edges.each{|edge| togos << edge unless edge.faces[0] }
		model.active_entities.erase_entities(togos) if togos[0]

TIG · 29 Sept 2016, 20:23

You are a "bit over your head"...
As you don't seem to understand what you are trying to do at each step...

All the code we have been talking about recently is to erase the unwanted edges if the new circle is not wholly within the targeted face.

Earlier code - which already worked - will find the face associated with any new edges which you just added and which have a face... and then you just do a pushpull on that that...

ado130 · 30 Sept 2016, 08:00

Yeah, you're right, I don't get it completely.

save now active edges
active_edges = model.active_entities.grep(Sketchup::Edge)
make a new group and add there circle
group = Sketchup.active_model.active_entities.add_group() gents = group.entities edges = gents.add_circle(center, dir, radius[i])
select edges, which makes this circle
new_edges = model.active_entities.grep(Sketchup::Edge) - active_edges
erase the unwanted edges
togos = [] ### empty array new_edges.each{|edge| togos << edge unless edge.faces[0] } model.active_entities.erase_entities(togos) if togos[0]
now last step, that you said; find the face associated with any new edges which I just added and which have a face
fac = nil new_edges.faces.each{|f|fac = f unless f.loops[1]} fac.pushpull(-10)

Is it correct now? I'd like to learn it (understand it), not only copy and paste the code.

TIG · 30 Sept 2016, 11:48

We are adding the circle onto an existing face [you never showed that step or set up the values for the circle itself ??]

You don't need to add the edges to a new group.
raw it directly over the face in the active_entities.
edges = Sketchup.active_model.active_entities.add_circle(center, dir, radius, segs)
Where center is a point on the face [or the plane of the face],
dir is the face.normal, radius is the circle's radius [NOT an array it's a dimension], and segs is the number of sides the circle will have.

When you draw the circle's edges there are three possible outcomes...
a) The circle intersects fully with the face and then all of those edges have two faces - so there's nothing to tidy up - next you can find/use the new face supported by one of the circle's edges and pushpull it to form the hole or notch [i.e. no face.loops[1]].
b) The circle misses the face completely, so all of its edges are faceless, so they all need deleting and the code exits.
c) The circle straddles the edge of the face. Now some edges are faceless and need deleting. At least one other circle's edge will support two faces and one of them is new - again this can be used for the pushpull...

The use of the togos array to remove any faceless edges is OK.
The finding the face fac and pushpulling it is OK.

Unfortunately since your code added the circle into a group no new edges are found in the active_entities. So nothing to find with a face etc, so nothing to pushpull.

I suggest you first get it working in the active_context, then learn how to do it ALL inside a group.entities context to separate the geometry from the rest of the model and make finding new stuff easier...

ado130 · 1 Oct 2016, 11:27

I know, that the circle's radius is not an array, but that's not a whole code.

def notch(x, y, z, radius, depth, direction)
	countOfNotch = x.length.to_i
	countOfNotch.times do |i|
		model = Sketchup.active_model 
		center = [x[i], y[i], z[i]].map(&;to_f)				
		case direction[i]
			when "N"
				dir = Geom;;Vector3d.new(0,0,1)
			when "E"
				dir = Geom;;Vector3d.new(-1,0,0)
			when "S"
				dir = Geom;;Vector3d.new(0,0,-1)
			when "W"
				dir = Geom;;Vector3d.new(1,0,0)		
			when "F"
				dir = Geom;;Vector3d.new(0,-1,0)	
			when "B"
				dir = Geom;;Vector3d.new(0,1,0)				
			else
				dir = Geom;;Vector3d.new(0,0,1)		
		end		
		
		active_edges = model.active_entities.grep(Sketchup;;Edge)					
		edges = Sketchup.active_model.active_entities.add_circle(center, dir, radius[i])
		new_edges = model.active_entities.grep(Sketchup;;Edge) - active_edges
		togos = [] ### empty array
		new_edges.each{|edge| togos << edge unless edge.faces[0] }
		model.active_entities.erase_entities(togos) if togos[0]
		fac = nil
		new_edges.faces.each{|f|fac = f unless f.loops[1]}
		fac.pushpull(-depth)
	end
end

Is it necessary set the seg?, I think there is a default value.
So I add circle into active_entities.

For point a) I've a separate code (the above code) - make drill; I use it, when I know, that the drill (circle) intersects fully with the face (i.e. block).

TIG · 1 Oct 2016, 12:35

You are right in that the 'segments' in add_circle will default to 24 if you do not pass a final argument, but you might well want to make the circle less segmented if it's very small or more segmented if it's very large - it depends on what you are to do with it next...
If it's in 3d-printing look up 'versine' as the segment's length should never be 1/1000" or less, and of course this depends on the radius and number of segments...

A circle's radius is a dimension, but your code method seems to receive an argument, which you name radius but you then treat it as an array, to take radius[i] with i derived from the notch counter...
So it is an array ?
If so, then I think it'd be clearer for anyone reading it [including yourself] to call it say radii, rads or radiuses and then set rad = rads[i] before using it...
Also your direction sees to be an array too !

Without seeing all of your related code it is all but impossible to deduce what you are doing at each step.

Common practice is to name a 'collection' - like an array - plural and then take an element in it named in the singular...
rads >>> rad
dirs >>> dir
pts >>> pt
edges >>> edge
faces >>> face
etc

Another minor thing...
model = Sketchup.active_model can be set at the start of the method, resetting it at each iteration will slow its processing up slightly.

If you have other code checking that the drilled hole is wholly on the face so there is no 'part-circle' side holes, then the new edge collection and unfaced edge deletion is superfluous, since every edge of the circle is faced... try ### out parts to see what's not needed...

ado130 · 1 Oct 2016, 18:31

Yes, radius, depth and direction are arrays with the float numbers.
In another part of code I only read txt file line by line and split it into this arrays.

I've two arrays, in first array are "drills" (coordinates, depth, etc), that are whole on the face, and second array, where I don't know if the imaginary center of notch is on the face or not.
So, function for drill works fine, but still I've problem with notches.

The whole code has 460 lines, so .. if you want, I can send it via PM.

Thanks for the advice of the name.

In future if it will work, I wanna buy Pro version and do sth like client-server. This script will run on the server, and i.e. you like a client send points (These can be generated from the C# program) and send to server. He process them, sent back Sketchup model to the client and client can open it with Sketchup View.
So I've one more question. Is this possible?, I think the part where Pro version can automaticaly open ruby script and save the model.

TIG · 1 Oct 2016, 19:05

In both SketchUp versions, all scripts automatically load from the Plugins folder as SketchUp starts.
If their code includes some 'self-running' lines, then those will start a process you desire...
For example, this happens with Observers etc - like my LayerWatcher toolset, which adds an observer to the model's layers, and also some extra functions to the context-menu etc...

Also once some process has completed then you can use various API methods to save the model as a SKP [even with different version] or other exportable formats [more are available in Pro], you do not have to prompt for a file-name, although it is an option, your code can [re]set the file name so the original is not overwritten, even make a new sub-folder to take the file[s] etc...

ado130 · 2 Oct 2016, 11:09

Now I've it in Plugins->Extensions, so then I only "delete" this manually run script and it should work automatically.
I suppose that this API can be used as a script.
I only need save it another work will do a C# program, then it's easy.

About notches, can you help with that? I'm a bit lost how to proceed now.

Two more questions:

is possible do a fillet (radius) on rectangel blocks?
Exist a way, how to secure script, I think sth like non-readable, *.rb is possible open in whatever and *.rbz is just a "zip", so..

TIG · 2 Oct 2016, 13:06

@ado130 said:

Now I've it in Plugins->Extensions, so then I only "delete" this manually run script and it should work automatically.
I suppose that this API can be used as a script.
I only need save it another work will do a C# program, then it's easy.

About notches, can you help with that? I'm a bit lost how to proceed now.

Two more questions:

is possible do a fillet (radius) on rectangle blocks?

Exist a way, how to secure script, I think sth like non-readable, *.rb is possible open in whatever and *.rbz is just a "zip", so..

To run it manually leave the menu adding code in, put # in front of each line later to stop that menu forming...

I don't understand your latest 'question' about notches...

You can do a 3d fillet on a 3d block -see Fredo's RoundCorner tool for a tour-de-force on that.
But in principle you and a 1/4 circle 'negative-out-of-a-square face' perpendicular onto the center of selected path edge and use those path edges with a followme command to subtract the geometry...
The standard way to make a script is to make am RB loader file and a same-name subfolder containing your main code.
The RB sets up the Extension and loads the code file with in the subfolder by name [no file-type needed] [that code can then 'require' other files in there too].
The RB and subfolder of files are supplied in an RBZ archive - this is simply a ZIP file renamed with another file-type. Preferences > Extensions > Install Extension processes the RBZ and adds the RB+subfolder into the user's Plugins subfolder.
RBZ is not secure as it's a binary format ZIP file which can easily be extracted.
When developing scripts you'd normally leave all of your scripts in the subfolder as RB for ease of access.editing etc.
If you want to stop others seeing your main code you can encrypt the RB files within the RBZ's subfolder - the loader must remain an RB file - but it won't [shouldn't] contain sensitive code anyway...
The most common encryption seen is RBS. This works on all SketchUp versions but is known to have be cracked long ago, and so it's relatively weak - although it stops the casual user from seeing the contents. There used to be a standalone exe available from SketchUp to do this encryption, since v2016's launch that's been withdrawn.
Now you must register as a developer and submit to SketchUp your full RBZ containing RB files and they will process it and you can download it to distribute [ http://extensions.sketchup.com/en/developer_center/extension_security ].
The returned RBZ contains a 'signed' hash file which seeks to ensure >=v2016 users, albeit weakly, that the contents of that RBZ have not be changed at all since that 'signing' process [i.e. the original RB/RBS/RBE/JS/CSS/HTM/HTML].
When submitting the RBZ you can choose to leave the subfolder's scripts as RB files, or encrypt them.
The two methods offered are RBS and RBE.
As said earlier, the RBS encryption is relatively weak, but it has the advantage of being usable on all current SketchUp versions [although the signing site says it's for v2015 and older it will also work in v2016.
The newer RBE format has not yet been cracked [as far as we know], so it offers more security.
However, you will then limit your potential user-base to those with >=v2016 - something to consider for a commercial extension, where the very nature of encryption is paramount, but numbers count too.
So if you want protection choose either RBS or RBE, as you consider appropriate.
Depending on which you variant choose, all RB files in subfolder the RBZ are processed and replaced with encrypted versions.
Oddly the signing site lets you choose to have both RBS and RBE encrypted versions in the same RBZ.
IMHO this is somewhat reckless - the hackers out to get your intellectual property can readily crack the RBS version anyway, and even worse - since the RBS and RBE contain identical code when decrypted it gives the hackers a told-hold in breaking the RBE encryption set up - since they then know what should be produced during decryption... So if you decide that RBE is for you, then never supply an RBS version with it too...
If you compile some of your code in C+ etc that's binary and hard to decrypt.
If you want to sell it as licensed software there are methods available via the API and SketchUp's EW, or several alternative private licensing methods too...

ado130 · 2 Oct 2016, 15:30

Thanks for comprehensive answer, I'll try it.
In first point you describe, when the rectangular exist, is it good way?, or is better to do fillet while drawing?

About notches

		active_edges = model.active_entities.grep(Sketchup;;Edge)					
		edges = Sketchup.active_model.active_entities.add_circle(center, dir, radius)
		new_edges = model.active_entities.grep(Sketchup;;Edge) - active_edges
		togos = [] ### empty array
		new_edges.each{|edge| togos << edge unless edge.faces[0] }
		model.active_entities.erase_entities(togos) if togos[0]
		fac = nil
		new_edges[0].faces.each{|f|fac = f unless f.loops[1]}
		fac.pushpull(-depth)

It's not a whole code, but the rest is the same (see above).
But still is there a problem.

TIG · 2 Oct 2016, 16:43

Do you run it with the Ruby Console open ?
What are the error messages ?

To see output at each stage add p in front of the operation...
e.g.

p active_edges = model.active_entities.grep(Sketchup::Edge) p edges = Sketchup.active_model.active_entities.add_circle(center, dir, radius) p new_edges = model.active_entities.grep(Sketchup::Edge) - active_edges ... p togos ... p fac

To show how each has been set...

ado130 · 2 Oct 2016, 17:03

237: new_edges[0].faces.each{|f|fac = f unless f.loops[1]}

sdmitch · 2 Oct 2016, 17:16

@ado130 said:

		active_edges = model.active_entities.grep(Sketchup;;Edge)					
> 		edges = Sketchup.active_model.active_entities.add_circle(center, dir, radius)
> 		new_edges = model.active_entities.grep(Sketchup;;Edge) - active_edges
> 		togos = [] ### empty array
> 		new_edges.each{|edge| togos << edge unless edge.faces[0] }
> 		model.active_entities.erase_entities(togos) if togos[0]
> 		fac = nil
> 		new_edges[0].faces.each{|f|fac = f unless f.loops[1]}
> 		fac.pushpull(-depth)

But still is there a problem.

Problem

.add_circle doesn't create a face only the bounding edges. new_edges=edges1. the circle is being added to the model context therefore there is no interaction with the entities in the group. add a group inside the original group. save the faces in original group. do the .add_circle inside the new group then explode it. this will cause the circle edges to merge with the original group and create the circle face. circle_face=current_faces-faces. delete new_edges that have no associated face.

TIG · 2 Oct 2016, 19:10

Thanks Sam.
Somewhere in the many iterations of this code... the circle in the group and its explosion got lost...
After that it should work

ado130 · 2 Oct 2016, 20:10

I am slightly confused now because before you said

@unknownuser said:

You don't need to add the edges to a new group.
raw it directly over the face in the active_entities.
edges = Sketchup.active_model.active_entities.add_circle(center, dir, radius, segs)

So what should I do?
If I understood Sam correctly, I need sth like
group = Sketchup.active_model.active_entities.add_group() gents = group.entities active_faces = model.active_entities.grep(Sketchup::Face) edges = gents.add_circle(center, dir, radius) group.explode circle_face = model.active_entities.grep(Sketchup::Face) - active_faces
.. and then?
I'm not sure what is meant by "add a group inside the original group".

By the way, thanks Sam, or, thanks to both.

sdmitch · 2 Oct 2016, 20:59

@ado130 said:

group = Sketchup.active_model.active_entities.add_group() gents = group.entities active_faces = model.active_entities.grep(Sketchup::Face) edges = gents.add_circle(center, dir, radius) group.explode circle_face = model.active_entities.grep(Sketchup::Face) - active_faces
.. and then?
I'm not sure what is meant by "add a group inside the original group".

By the way, thanks Sam, or, thanks to both.

###group = Sketchup.active_model.active_entities.add_group();
### remove previous statement since you have already defined "group".
gents = group.entities
active_faces = gents.grep(Sketchup;;Face);### modified
circle_group = gents.add_group; cge = circle_group.entities;### new
edges = cge.add_circle(center, dir, radius);### modified
circle_group.explode;### new
circle_face = (gents.grep(Sketchup;;Face) - active_faces)[0];### modified

ado130 · 3 Oct 2016, 15:10

I had never defined the group in this method previous.
This is what I have now:

def notch(x, y, z, radiuses, depths, directions)
	model = Sketchup.active_model 
	countOfNotch = x.length.to_i
	countOfNotch.times do |i|
		
		center = [x[i], y[i], z[i]].map(&;to_f)		
		radius = radiuses[i]
		depth = depths[i]
		direction = directions[i]
		
		case direction
			when "N"
				dir = Geom;;Vector3d.new(0,0,1)
			when "E"
				dir = Geom;;Vector3d.new(-1,0,0)
			when "S"
				dir = Geom;;Vector3d.new(0,0,-1)
			when "W"
				dir = Geom;;Vector3d.new(1,0,0)		
			when "F"
				dir = Geom;;Vector3d.new(0,-1,0)	
			when "B"
				dir = Geom;;Vector3d.new(0,1,0)				
			else
				dir = Geom;;Vector3d.new(0,0,1)		
		end		
		
		gents = group.entities
		active_faces = gents.grep(Sketchup;;Face);### modified
		circle_group = gents.add_group; cge = circle_group.entities;### new
		edges = cge.add_circle(center, dir, radius);### modified
		circle_group.explode;### new
		circle_face = (gents.grep(Sketchup;;Face) - active_faces)[0];### modified	
		circle_face.pushpull(-depth)		
	end
end

Of cource, I define a group in method, where I draw a rectangel block, but it's independently. So first I call this method, it'll draw several blocks, and then, if is necessary (according to input file) I'll call a method for notch.