COUNTING? GROUPING?

[fade2blackened]

Hello!

First of all, imagine this building, which has some big "panels" (concrete panels) all over it:



Now, imagine that, all those "big concrete panels" have some "small panels" (something made with rock, for eg.), like this now:



Ok.
As you can see, there are several sizes of "small rock panels", which could be grouped by the "big ones", like this (I´m gonna call the BG=big ones, and SM=small ones):

GROUP BG1:
- SM1 / SM1 (Like it repeated 2 times)
- SM2
- SM3

GROUP BG2:
- SM1 (yeah, again, for example!)
- SM5
- SM6
- SM7

ETC, ...

You see, even though the big ones sometimes have some similar small ones, they´re still grouped separately. That means, the big ones could be the "group name", and the "small ones" would be the objects inside these groups.


This lisp would have to "compare" both size and "grouping", so it could name corretly, and also tell me that I have 2 BG1, 10 BG2, etc...


Maybe this lisp would create separate blocks for each group in a folder.
Each SM would be a block and the BG groups would be blocks too, with blocks "inside".

After all that I would use "Attribute Extractor" to count all of them.

All I would have to do is to draw the polylines, for the BG and SM, and the lisp would compare, name, group, make blocks, etc... All alone.

Is it... too complicated?

[fixo]

Hi,
I thought you need to do something like this
(just an idea only):
I created a couple of blocks with following names:
"12.5x18.5" "18.5x18.5" "38.5x18.5" "38.5x38.5" "52.0x38.5" "73.0x38.5" etc. etc.
All the block you can to store into one library block file.
All the blocks with insertion point in the lower left corner,
with one invisible constant attribute:
tag - "SIZE"
prompt - "Tile size"
value - "(38.5x18.5)", etc - (or length multiple by width)
Panel size:
length - 120.
width - 90.

;get tile length by block name
(defun get_length (block_name)
  (atof
    (substr block_name 1 (vl-string-search "x" block_name))
  )
)

;get tile width by block name  
(defun get_width (block_name)
  (atof
    (substr block_name (+ (vl-string-search "x" block_name) 2))
  )
)

;get all the tiles
(defun get-tiles-by-first (len	       wid	   lower_gap
			   upper_gap   gap_between left_gap
			   right_gap   tile_len	   tile_wid)

    ;| * : go through tiles in counterclockwise direction : |;
    (list
    ;| #1 : lower left tile : |;
    (cons tile_len tile_wid)
    ;| #2 : lower right tile : |;
    (cons (- len (+ left_gap tile_len gap_between right_gap))
	  tile_wid
    )
    ;| #3 : upper right tile : |;
    (cons (- len (+ left_gap tile_len gap_between right_gap))
	  (- wid (+ lower_gap gap_between upper_gap tile_wid))
    )
    ;| #4 : upper leftt tile : |;
    (cons tile_len
	  (- wid (+ lower_gap gap_between upper_gap tile_wid))
    )
  )
)

  ;get all the blocks
  (defun get-block-names (block_name   len	  wid
			lower_gap    upper_gap	  gap_between
			left_gap     right_gap
		       )
  (setq	tile_len (get_length block_name)
	tile_wid (get_width block_name)
  )
  (setq	tiles_data
	 (get-tiles-by-first
	   len		wid	     lower_gap	  upper_gap
	   gap_between	left_gap     right_gap	  tile_len
	   tile_wid
	  )
  )
  (mapcar (function
	    (lambda (x)
	      (strcat (rtos (car x) 2 1) "x" (rtos (cdr x) 2 1))
	    )
	  )
	  tiles_data
  )
)

;;;TesT : 
(setq block_names
       (get-block-names
	 &#40;strcat &#40;getstring "\nEnter first tile length with decimal delimiter <like 73.0> \n"&#41;
		 "x"
		 &#40;getstring "\nEnter a tile width with decimal delimiter <like 38.5>\n"&#41;&#41;
	 120. ;panel length
	 90. ;panel width
	 3.125 ;upper gap
	 5.875 ;lower gap
	 4. ;gap between
	 2. ;left gap
	 2. ;right gap
	 &#41;
&#41;

~'J'~

[fixo]

Going further...

; to insert block from block library file
(defun dwg-insert (dwg_name	block_name   ins_point	  x_scale
		   y_scale	rot_angle    /		  lib_file
		  )
  (if (not (tblsearch "BLOCK" block_name))
    (progn
      (setvar "cmdecho" 0)
      (setq lib_file (findfile dwg_name))
      (if (not lib_file)
	(progn
	  (alert "Library is not found")
	  (exit)
	  (princ)
	)
	(progn
	  (command "-insert" lib_file)
	  (command nil)
	)
      )
    )
  )
  (if (tblsearch "BLOCK" block_name)
    (progn
      (command "-insert"   block_name  "_X"	   x_scale
	       "_Y"	   y_scale     "_R"	   rot_angle
	       ins_point
	      )
      (command "purge" "_B" "*" "_N")
    )
  )
  (setvar "cmdecho" 1)
  (princ)
)
; Test :
(defun C:test1
       (/ block_name dwg_name ins_point rot_angle x_scale y_scale)
  (setq	dwg_name   "C:/MyLisp/tornillo-com.dwg"
	block_name "ALLEM-cc-03-08"
	ins_point  (getpoint "\nPick ins point >>>\n")
	x_scale	   1.
	y_scale	   1.
	rot_angle  0.
  )
  (dwg-insert
    dwg_name block_name	ins_point x_scale y_scale rot_angle)
  (princ)
)
;CaLL : (C:test1)

Then you can to count all the blocks
and write data in to any file i.e. txt-file:

(defun sub-total (lst elem / count)
  (setq count 0)
  (while (member elem lst)
    (setq count (1+ count))
    (setq lst (cdr (member elem lst)))
  )
  count
)
;CaLL : (setq sub-count (sub-total count_list bname))
(defun get-total (source_list match_list / data_list)
  (foreach i match_list
    (setq tmp	    (cons i (sub-total source_list i))
	  data_list (cons tmp data_list)
    )
  )
  data_list
)
;CaLL : (setq data_list (get-total count_list bname_list))
(defun get-count (/ bname bname_list count_list elist en i ssb)
  (setvar "cmdecho" 0)
  (command "zoom" "e")
  (setvar "cmdecho" 1)
  (if (setq ssb (ssget "_X" (list (cons 0 "INSERT") (cons 2 "*#x#*"))))
    (progn
      (setq i -1)
      (repeat (sslength ssb)
	(setq en    (ssname ssb (setq i (1+ i)))
	      elist (entget en)
	      bname (cdr (assoc 2 elist))
	)
	(if (not (member bname bname_list))
	  (setq bname_list (cons bname bname_list))
	)
	(setq count_list (cons bname count_list))
      )
    )
    (alert "No blocks found here")
  )
  (get-total count_list bname_list)
)
;CaLL : (setq data (get-count))
(defun write-data (data / fname)
  (setq
    fname (getstring
	    "\nEnter file name to write data in without extension :"
	  )
  )
  (setq fname (open (strcat (getvar "dwgprefix") fname "." "txt") "w"))
  (foreach i data
    (prin1 i fname)
  )
  (close fname)
  (princ)
)
						  ;CaLL :(write-data data)
(defun read-data (/ data_list fname rline)
  (setq	fname (getstring
		"\nEnter file name to read data without extension :"
	      )
  )
  (setq fname (open (strcat (getvar "dwgprefix") fname "." "txt") "r"))
  (setq rline (read-line fname))
  (setq data_list (read (strcat "(" rline ")")))
  (close fname)
  (reverse data_list)
)
;CaLL :(setq ret_data (read-data))

;;TesT : 
(defun C:test2 (/ data)
  (setq data (get-count))
  (write-data data)
  (princ)
)
;CaLL : (C:test2)

~'J'~

[fade2blackened]

Hi Fatty,

First I´d like to thank you to put so much of your time in it.

This lisp is not doing "exactly" what I was thinking about.
Maybe I´m missing something. Let´s see:

- I create the polyline
- I create the attribute
- I create the block

After all that I write TEST2, then the text file is created.

I put all the three parts of the code together. Was I supposed to do that?

Well, if I did everything correct, I´d have to do almost everything on my own. Imagine a whole building, with hundreds of big panels, which of them with different small panels. Let´s say this building have 200 big panels. And each big panels has 4 small panels.

It would give me like 800 small panels.

Maybe my problem here is the english.... sorry!


All I want to do BEFORE the lisp getting in is:

- draw big rectangles (the yellow ones, in my first post)
- draw small rectangles inside the big ones (the grey ones now)

All polylines...
The "blocking" would be the "lisp´s job".

I don´t think I know all the words to make my self clearer...
And I don´t even know if it´s possible to do what I want...

Any ideas?

THank you very much!

[fixo]

Hi Fatty,

First I´d like to thank you to put so much of your time in it.

This lisp is not doing "exactly" what I was thinking about.

Hi,

Sorry now is too late for me, see you tomorrow
I will try to do what you asked me, but don't sure if this will be

~'J'~

[fixo]

Sorry, buddy, I couldn't understand exactly what you need
because of my poor english level
I have stopped my weak attempts to help you ...

Here is an example how to fill panel with blocks, change all
by your needs:

(vl-load-com)
;get all the tiles
(defun get-tiles-by-first (len	       wid	   lower_gap
			   upper_gap   gap_between left_gap
			   right_gap   tile_len	   tile_wid)

    ;| * : go through tiles in counterclockwise direction : |;
    (list
    ;| #1 : lower left tile : |;
    (cons tile_len tile_wid)
    ;| #2 : lower right tile : |;
    (cons (- len (+ left_gap tile_len gap_between right_gap))
	  tile_wid
    )
    ;| #3 : upper right tile : |;
    (cons (- len (+ left_gap tile_len gap_between right_gap))
	  (- wid (+ lower_gap gap_between upper_gap tile_wid))
    )
    ;| #4 : upper leftt tile : |;
    (cons tile_len
	  (- wid (+ lower_gap gap_between upper_gap tile_wid))
    )
  )
)
;;get all the origins
(defun get-origos (en lower_gap gap_between 
		   left_gap tile_len tile_wid /
		   ll obj orig1 orig2 orig3 orig4 up_point ur)
  
      (setq obj (vlax-ename->vla-object en))
      (vla-getboundingbox obj 'll 'ur)
      (setq orig1 (vlax-safearray->list ll)
	    up_point (vlax-safearray->list ur)
	    orig1 (list (+ (car orig1) left_gap)(+ (cadr orig1)lower_gap)(caddr orig1))
	    orig2 (list (+ (car orig1) tile_len gap_between)(cadr orig1)(caddr orig1))
	    orig3 (list (car orig2)(+ (cadr orig2) tile_wid gap_between) (caddr orig1))
	    orig4 (list (car orig1)(cadr orig3)(caddr orig1)))
      (list orig1 orig2 orig3 orig4))

(defun C:test4(/ amod bname ccol clyr dim_list en gap_between
	       ins_pt left_gap len lower_gap orig_list pmt_str
	       right_gap dim_list ss size_list tag_str upper_gap wid)
  
  (setvar "cmdecho" 0)
  (setvar "osmode" 0)
  (setq ccol (getvar "cecolor"))
  (setq clyr (getvar "clayer"))
  (setq amod (getvar "aflags"))
  (setvar "cecolor" "253")
  (setvar "clayer" "0")
  (setvar "aflags" 1); invisible attribute mode
  
  ;; here is dimension list for all the first (lower left) tiles
  ;; for all the big panels (or you can draw these panels, and
  ;; get their coordinates and dimensions)
  
  (setq size_list '((18.0 . 18.0)
		    (38.0 . 18.0)
		    (52.5 . 18.0)
		    (52.5 . 38.0)
		    (72.5 . 38.0)
		    (72.5 . 52.5))
	len 120.;panel length
	wid 90. ;panel width
	lower_gap 6.
	upper_gap 3.125
	gap_between 4.
	left_gap 2.
	right_gap 2.);_ setq
  
  (repeat (length size_list)
    (setq indx (car size_list))
    (setq ss (ssget "_:S" (list (cons 0 "*POLYLINE")))
	  en (ssname ss 0))
    (redraw en 3)
	 (setq dim_list (get-tiles-by-first len	 wid lower_gap
			   upper_gap   gap_between left_gap
			   right_gap   (car indx) (cdr indx))
	       orig_list (get-origos en lower_gap gap_between 
		   left_gap (car indx)(cdr indx))
	       )
	   (repeat 4
	      (setq bname   (strcat (rtos (caar dim_list) 2 1) "x" (rtos (cdar dim_list) 2 1))
	      ins_pt  (car orig_list)
	      tag_str "TILE"
	      pmt_str tag_str
	)
	(if (not (tblsearch "block" bname))    
	(make-tile-block
	  bname
	  ins_pt
	  tag_str
	  pmt_str
	  (caar dim_list)
	  (cdar dim_list)
	)
	  )
	     (command "-insert" bname ins_pt 1 1 0)
	     (setq dim_list (cdr dim_list)
		   orig_list (cdr orig_list))
      )
    (redraw en 4)
(setq size_list (cdr size_list))	     
)	   

  (command "regenall")
  (setvar "cecolor" ccol)
  (setvar "clayer" clyr)
  (setvar "aflags" amod)
    (setvar "osmode" 703)
  (setvar "cmdecho" 1)
  (princ)
)

~'J'~

[fade2blackened]

Dude, I can´t understand how it works...
Could you give me an example?

Thank very much!

[fixo]

Dude, I can´t understand how it works...
Could you give me an example?

Thank very much!

Hi again
There is no need an example
Simply draw a few yellow rectangles with
dimensions: Length = 120, Width = 90. and then
select these one by another
This routine will fill these panels with blocks

~'J'~