Find and replace multiple components?

TIG

Are your doors [etc] all separate components or scaled versions of the same one?
If they are scaled then the swap should be seamless.
If they are separate versions [which is more likely because scaling will affect rail/stile sizes] - e.g. Door-18-24-A, Door-20-24-A, Door-24-24-A etc then to use a scripted 'swapper' you at least need the replacements to follow the same pattern of 'name-coding' - e.g. Door-18-24-B, Door-20-24-B, Door-24-24-B etc - i.e. let's say the coding is Element[Door]-Width[18]-Height[24]-Code[A].
Once you have a logical way of encoding an element's name I can show you how to make a script that will go through the selected components and find their Element, Width, Height and Code and then swap for available elements with another code. A version that would run in the Ruby Console [initially at least] would take the form swap_components('-A','-B') - it would find all code-A instances in your selection and swap them with any available code-B versions - either using those already loaded into the SKP or perhaps available in a specific set of folders in the ../Components folder - e.g. a /Doors folder and a /Drawers folder... It relatively easy to find components that have a name ending in '-A' and find and the source equivalently name one, but with its name ending in '-B'. The secret is in having a logical naming convention for components that might get swapped - I used A, B etc as the 'Code' but it could be more complex - swap_components('-A-Oak-Antique','-B-Maple-Limewash') etc etc...

dedmin

I'm dealing with this problem like this - all my doors have the same axes place and orientation - upper left back corner. I'm scaling only with FredoStretch from left to right - this way component's axes doesn't move and thickness stay the same. If I want to replace some doors that have different size I firs place the component aside, change the size to be the same as the ones i want to replace and then replace

http://www.youtube.com/watch?v=Lom6aWnG7zA

nickchun

Once again guys thanks for your replies,
The components are made by Fredo scaling an original, which leaves the stiles and rail sizes intact, but then they are saved as individual components into a library.
Considering the kitchens I design can have upwards of 50 frontages I think the script using codes is what I had in mind but I have no experience of writing scripts in ruby. Looks like I will have to try and learn but I struggle with some of the concepts ( the last program I wrote was in BASIC 30 yrs ago and was pretty simple). TIG, do you think it could be a fairly small script?#

Thanks
Nick

TIG

IF you name your components logically then a script in the form swapcomponents("-aaa","-bbb") is straightforward - and quite simple - I can talk you through it... Once you have something working vis the Ruby Console it#s easy enough to add a menu item and dialog, even a toolbar and so on...

First off - make a logical component-naming strategy/
Then write is a simple step-sheet explaining how you'd like to use the new tool... e.g.

I select various cabinets where I want to swap one type of door [and drawer] for another.
I activate the new tool tell it what code to find and what code to replace it with... and it automatically finds equivalent doors [and drawers] in the model [or perhaps SKPs in folder[s]] in ../Components/.
It then uses/loads them and replaces the current component instance with the required definition.
A dialog reports what's been changed and/or any errors.
It is one step undo-able.
For example always name doors 'Door-WWW-HHH-FINISH-CODE' and then all we have to do is swap components with the same base but a new FINISH and/or CODE - In the input you could type Door*-Oak-A and in the output type Door*-Maple-A and all doors code A would change from 'Oak' to 'Maple'; or Door*-A >>> Door*-B would swap from code A to code B - if there were no Oak versions of code B doors then the closing dialog tells you!
On a more global system *-A >>> *-B tries to swap all type A 'fitments' to type B.
If things are 'nested' - components inside groups etc then it's more tricky but not impossible...
You could also swap ironmongery from Handle-*-A >>> Handle-*-B.
See the schema ?

nickchun

Thanks TIG, I get the gist of what your saying ( only the gist mind) and need to spend time learning ruby before I can make a start. I have no idea if I'm capable of doing it yet though. Changing the handles is simple enough anyway, I just use a horizontal and vertical version of each and use "replace instances".
On the subject of nesting, perhaps it would be simpler if I made libraries of the whole cabinet in different sizes, types and door styles, and swapped the whole thing.
I don't uaually show internals so it would be just a box tacked onto the door/drawer.
Thanks again
Nick

TIG

The secret is in the component definition's coding so that a ruby can decide which swaps with what... the Ruby code is straight forward enough.

As you say swapping handles from one type to another is easy done with 'select instances' and then 'replace selected'. You can programmatically get Ruby to that, BUT you'd have a set of 'filters' that look at the component instances' definition's name and if it matches a given pattern then swap that instance's definition for another definition with a name that matches another pattern you have given it... Just imagine doing it manually - you decide on the type of door needed to be swapped - let's say it's type 'A' - in the component browser you find one of the door components that is a type A [there might be many variants] - 'select instances' highlights them, now find the equivalent sized door type 'B' and 'replace selected'. De-select everything and start again on the next type 'A' variant... With the Ruby version all you do it tell the tool what pattern of name 'Door--A' you seek and what pattern to replace it with 'Door--B' - it then makes lists of all of the different variants and processes them in turns and swaps their definitions to match the new name pattern, if there's an equivalent component available. It reports at the end. All it's doing is what you can do manually but automatically and without the risk of error...

nickchun

Thanks TIG, sorry I'm a bit slow replying. I have just started going through some ruby tutorials and will soon start experimenting. Its got to be worth the effort learning; the possibilities seem endless.......
Nick

JPMays

I'm running into an odd problem with swapping components as well. I have about 200 instances of one component, that I need to swap with another one. If I select an individual component, and right-click to swap, it works fine. If I select multiple, that option is not available. If I use the Component window and right-click on the component and Select All, they are all selected, but the option to Replace Selected is grayed-out and unavailable. What gives?

Gaieus

When you selected all the instances, do not right click on the definition of this component in the component browser but on the definition of the one you want to replace these instances with. There will be the menu item available...

xombie1912

@tig said:

Are your doors [etc] all separate components or scaled versions of the same one?
If they are scaled then the swap should be seamless.
If they are separate versions [which is more likely because scaling will affect rail/stile sizes] - e.g. Door-18-24-A, Door-20-24-A, Door-24-24-A etc then to use a scripted 'swapper' you at least need the replacements to follow the same pattern of 'name-coding' - e.g. Door-18-24-B, Door-20-24-B, Door-24-24-B etc - i.e. let's say the coding is Element[Door]-Width[18]-Height[24]-Code[A].
Once you have a logical way of encoding an element's name I can show you how to make a script that will go through the selected components and find their Element, Width, Height and Code and then swap for available elements with another code. A version that would run in the Ruby Console [initially at least] would take the form swap_components('-A','-B') - it would find all code-A instances in your selection and swap them with any available code-B versions - either using those already loaded into the SKP or perhaps available in a specific set of folders in the ../Components folder - e.g. a /Doors folder and a /Drawers folder... It relatively easy to find components that have a name ending in '-A' and find and the source equivalently name one, but with its name ending in '-B'. The secret is in having a logical naming convention for components that might get swapped - I used A, B etc as the 'Code' but it could be more complex - swap_components('-A-Oak-Antique','-B-Maple-Limewash') etc etc...

hello TIG can you help me for 1plugin i want to made i have the idea but i dont know about ruby console if you are interested please send me a private message
thanks a lot

antioche

Hi xombie1912 and TIG,

I would be interested in using the ruby script that you described, that is to say, run through the selection and swap components that match a specific name pattern with others.

More specifically in my case, I want to find modified dynamic components (automatically named by SketchUp for instance Name_of_initial_component#3 ) to revert them with the original component definition (Name_of_initial_component).

The reason for doing this is that I have create a Room dynamic component that calculates its floor area using the FACEAREA property. Inside each rooms are dynamic Windows and Door components. I need to have a separate instance of these windows/doors something else in the model to create a graphical schedule of doors and windows.

However, I need the Room dynamic components to recalculate FACEAREA() of a certain material, but this calculation is only updated when the component is redrawn (Right Click > Dynamic Components > Redraw). Unfortunately, this redraw causes all dynamic components inside them to become unique components (hence being renamed Name_of_initial_component#1 instead of Name_of_initial_component), so that they are now treated as separate definitions (although they are still identical) and the link to the schedule is broken (i.e. updating one does not update the other...). Not sure why...

The script would allow me to quickly run through the Room components and reassign the correct window/door definitions to the components it contains.

Alternatively, if you know a way to refresh a FACEAREA() calculation in a dynamic component without requiring a redraw? That would be my preferred solution...

Any suggestion or draft function of this Ruby function you described?

Cheers,

Teebs

tenquin

Boa Tarde!

TIG, poderia nos auxiliar como desenvolver o plugin para substituir portas?
Desde já agradeço.

TIG

@tenquin

Why do you need a plugin to swap doors?
Years ago I explained how to do it with the native tools...

Por que você precisa de um plugin para trocar as portas?
Anos atrás, expliquei como fazê-lo com as ferramentas nativas...

antioche

Hi TIG,
I suspect Tenquin may be referring to my post just above, which would involve relinking identical dynamic components that have lost their original definition due to a redraw action within nested dynamic components (see my post). Your suggested approach in your original post would not work, as the redrawn DCs get renamed as unique (although they are not).
Any suggestion on how to achieve this?

Cheers,

Teebs

TIG

OK

Let's consider this...
The original component is named [let's say] "DC" - so its unique-ified siblings are named DC#1, DC#2 etc...
So we can search the model's definitions for matching 'patterns' and replace their instances...
The naming has to be logical, and all instances the same...


model=Sketchup.active_model
defns=model.definitions
name="DC" # perhaps you'd use an inputbox to get this 'name' ?
defn=defns[name]
dcs=defns.find_all{|d| d.name =~ /^#{name}#/ }
# note how 'name' starts the match-pattern and has a following #
model.start_operation("Un-unique #{name}", true) # one-step undo
puts "Un-unique #{name}"
dcs.each{|d|
  p d.name # to see their names listed in the Ruby Console
  d.instances.each{|i| i.definition = defn }
  # replace with original
}
model.commit_operation
puts "Done"

This works within nested components etc...
You could check that the geometry/size etc of the instance of the original defn matches the instance of the to-be-un-uniqued definition, but that requires more convoluted code...

antioche

Many thanks for the quick feedback, TIG!
Seems to make a lot of sense. Not able to test right now (deadline looming on another project) but will test and feedback.

Teebs

tenquin

Olá TIG!
Boa tarde!
Obrigado pelo retorno.

Desculpe se não soube me expressar corretamente, na verdade preciso que o plugin troque todos os componentes que tem um parâmetro específico, no caso o parâmetro "modeloptions=portas inferiores"

Desde já agradeço.

Esses seriam os parâmetros de exemplo

Essa seria o componente a ser trocado, sendo que teria que manter as dimensões lenx, leny, lenz e posições x,y,z....

Essas seriam as portas de troca e estariam em uma biblioteca...

TIG

@tenquin

Yes, that's nothing like it !

You could try editing the code...


###....
dcs.each{|d|
  next unless d.get_attribute("dynamic_attributes", "modeloptions", "") == "portas inferiores"
  # this skips if it's not that type of dc ???
  p d.name # to see their names listed in the Ruby Console
  d.instances.each{|i| i.definition = defn }
  # replace with original
}
###...

tenquin

Obrigado mais uma vez TIG!

Vou estudar mais um pouco e tentar fazer,
sou novo em programação mas vou tentar até conseguir. rsrs

tenquin

@tig said:

OK

Let's consider this...
The original component is named [let's say] "DC" - so its unique-ified siblings are named DC#1, DC#2 etc...
So we can search the model's definitions for matching 'patterns' and replace their instances...
The naming has to be logical, and all instances the same...


> model=Sketchup.active_model
> defns=model.definitions
> name="DC" # perhaps you'd use an inputbox to get this 'name' ?
> defn=defns[name]
> dcs=defns.find_all{|d| d.name =~ /^#{name}#/ }
> # note how 'name' starts the match-pattern and has a following #
> model.start_operation("Un-unique #{name}", true) # one-step undo
> puts "Un-unique #{name}"
> dcs.each{|d|
>   p d.name # to see their names listed in the Ruby Console
>   d.instances.each{|i| i.definition = defn }
>   # replace with original
> }
> model.commit_operation
> puts "Done"
>

This works within nested components etc...
You could check that the geometry/size etc of the instance of the original defn matches the instance of the to-be-un-uniqued definition, but that requires more convoluted code...

Olá TIG

Desculpe minha insistência.
Há alguns meses conversamos sobre o código acima, que faz um script que substitui componentes.
Ainda não consegui fazer com que funcionasse, criei um componente com nome DC e copiei e colei o código no console Sketchup,mas não obtive resultado.
Estou me dedicando a Ruby, mas mesmo depois de ler o livro Automatic Skechup, não consegui identificar o que está errado...