help with a hatch pattern

[Anonymous]

Hello everyone

I'm trying to create a hatch pattern for two different sized tiles.

I want a 600Hx300W plank tile. Followed by a 600x600 tile. The tiles rows should be offset by 600.

Please look at the image attached.

I'm really trying to get this right... 

Any help would be GREATLY appreciated!

[Anonymous]

Hi,

  Try "superhatch" in express tools. I have tried it and works well.

STM

[Kent1Cooper]

That doesn't look difficult, but:

What is the grout/mortar joint width?

Are the tile sizes nominal  as with bricks [i.e. from center-of-joint to center-of-joint], or actual  [i.e. joint width is in addition to  tile size]?

Where should the origin from which it is all generated be?  At the middle of a joint intersection?  At the corner of a tile?

[Anonymous]

The grout is 3mm. The tile sizes are actual. 

So 600x300 tile, 600x600 tile + 3mm grout all around.

The origin should be from the middle of the joint intersection...

But this doesn't really matter so much?

[Kent1Cooper]

One more question:

The left is like the SuperHatch suggestion @Anonymous attached to Post 2.  The right would take less code.

[hugha]

try this:

;-------------------------------------------------------------------------
;        Written by HatchKitCS 
;        HatchKitCS (c)1990-2017 Cadro Pty Ltd
;        www.hatchkit.com.au
;------------------------------------------------------------------------- 
;%VERSION=3.0
;%UNITS=INCH
*Andrew6P9V9grout3
;%TYPE=MODEL
0,0,0,-603,-603,300,-606
89.9447802041,300,0,113364.057228,-4.7434532941,600,-114573.053496
180,300,600,603,603,300,-606
-90.0552197959,0,600,113364.057228,-4.7434532941,600,-114573.053496
0,303,0,-603,-603,600,-306
89.9447802041,903,0,113364.057228,-4.7434532941,600,-114573.053496
180,903,600,603,603,600,-306
-90.0552197959,303,600,113364.057228,-4.7434532941,600,-114573.053496

This skewed arrangement requires 8 defining elements whereas any rectangular arrangement would require 16. 

This pattern has been generated to load to Revit as I note you have also posted a request in that category.

Please note you should load the HatchKit Add-In for Revit and utilise its Import command to load this pattern to Revit (any version between 2013 and 2018 inclusive) as it will be rejected as too large by the Revit Fill Manager.    

hope this helps

Hugh Adamson

www.hatchKit.com.au

[Anonymous]

Hmm my reply didn't post :S

Kent, 

The one on the right, continuous stagger, is exactly what I want.

[Kent1Cooper]

Either something was drawn wrong in the objects from which Hatchkit was asked to generate that code, or Hatchkit itself is flawed.  What's with a line set at an angle of 89.9447802041 degrees, and an X-offset value of 113364.057228 units?  This should have only 0- and 90- degree directions [or could include 180 and/or 270, but there's no need], and offset values like 303/603/903/1203.

Also, they wanted the origin at the middle of a joint intersection, not at the corner of a tile, as this would do it.

I'm prepared to do something now that there's an answer to my stack-vs.-stagger question -- coming soon....

[phanaem]

Andrew,

Use the native pattern "AR-B88". It is a square-tiled hatch. Set the ORIGIN where is convenient for you (bottom-left of the border etc)

To set the proper scale, select the hatch and change the scale in the properties dialog.

Type MEASUREMENT to see the hatch pattern used. 0 means Imperial and 1 means Metric.

For MEASUREMENT = 0, set the scale to TILE_DIM/8. For you, it should be 603/8.

For MEASUREMENT = 1, set the scale to TILE_DIMx10/2032. i.e. 6030/2032.

[hugha]

Hi Kent,

there is nothing wrong, if you actually try the pattern in practice you will see the slight difference from vertical (0.055 degrees) or about 0.5mm at 600mm is imperceptible.     

This allows the skew to eventually line up properly  over the skipped interval of 113364.05722.  

I took advantage of OP's not being too concerned about the origin. 

To be honest, there was an error in my posting, to draw the pattern within a rectangular arrangement you will need 72 elements, not 16 and certainly not the 8 that form the pattern I published.  Rather less work to lay out.

Hugh

[hugha]

Here is another where the vertical joints are offset slightly to allow the repetition to line up in the same way as those laying the tiles would normally do to follow a wall -

;-------------------------------------------------------------------------------
;        Written by HatchKitCS
;        HatchKitCS (c)1990-2017 Cadro Pty Ltd
;        www.hatchkit.com.au
;-------------------------------------------------------------------------------
;%VERSION=3.0
;%UNITS=INCH
*Andrew6P9V9grout3
;%TYPE=MODEL
-90,1,601.5,603,-302,600,-1209
-90,904,601.5,603,-302,600,-1209
0,1,1.5,-302,-603,300,-606
0,1,601.5,-302,-603,300,-606
-90,301,601.5,603,-302,600,-1209
180,904,601.5,302,603,600,-306
180,904,1.5,302,603,600,-306
90,304,1.5,603,-302,600,-1209

This pattern has an enclosing template 906mm wide by 603 tall overall which drifts a little to the left if laid so each 4-way grout joint exactly lines up and the enclosing rectangle for such an orthogonally laid pattern can be surprisingly large and daunting to fill in.

hope this helps.

Hugh Adamson

[Kent1Cooper]

---

@Kent1Cooper wrote:

... -- coming soon....

---

Well, I find that this can't be done in the usual way--something's got to give.  Either A) you accept the skew in the HatchKit version, or B) you make the sizes nominal between centers of joints, or C) the larger tiles have to be 600 units high x 603 units wide, as in the image [which visually exaggerates the joint widths for clarity], or D) you accept a slight offset between vertical joints, which will require a very  much longer pattern definition, or E) you do it as a single-line pattern, without showing both sides of the joints.

The only way for this to work practically as a pattern definition with clean angles and offsets and 8 lines of code is for things to line up  in a certain way -- the white segments [chosen arbitrarily -- the right edges of the tiles in every third course] would be defined in one  lineset definition, and for that to be viable, must align.  If the joints line up for that purpose [the yellow phantom lines], and the smaller tiles are 300 units wide, and the joints are 3 units wide, then the larger tile must be 603 units wide.

If the larger tiles are really 600 units wide, then there will be a slight offset/misalignment between vertical joints, either at  the crossings [EDIT: looks like that's @hugha's approach in Post 11] or comparing joints 3 courses apart [which is what would take the very much longer definition in my D) option above].  And  that must be true for the physical installation of tiles as well as in the AutoCAD pattern definition, which means that a single-line pattern would have to be slightly off from the reality.

[hugha]

If the tiles are laid so all 4-way grout intersections form a straight cross then every third row will drift to the left by 3mm.  A practical installer would cater for this by laying each third row offset to the right by 3mm or more tidily each row by 1mm to avoid the extra work of cutting successively larger strips from the majority of tiles along the left and right.  

An unadjusted pattern in a strictly rectangular arrangement will repeat  vertically when all vertical elements align which will happen after the pattern drifts to the left by 906 mm, requiring 906 rows of tiles.  So it would require rather more than the 72  tile-edger elements as I previously estimated, instead requiring  906*8 = 7248 to fit in a rectangular arrangement measuring 906*603 = 546,308mm high and 303+603 = 906mm wide.  

This impractically large result imposed by confining patterns to a purely rectangular arrangement can be avoided by 

1)   adopting a skewed arrangement containing slight misalignments (my first submission) or

2)   mimicking a practical tiler (my second).  

This is a rather extreme example of a problem that occurs all too often with mixed tiling patterns.  

A shrewd manufacturer would reduce the tiles' actual sizes to allow for grout. 😉 

[Anonymous]

Who would have thought this pattern could get so complicated?

Thanks for explaining this in depth. I think I can deal with the larger tile being 603 in width.

I am adding vertical (height) dimensions for this tiling layout, not horizontal dimensions. Therefore it's not a big problem.

You can still achieve the continuous stagger pattern, correct?

[hugha · Accepted solution]

Adopting a slightly larger tile that won't markedly affect the overall appearance is a very sensible and  pragmatic solution.

;-------------------------------------------------------------------------------
;        Written by HatchKitCS
;        HatchKitCS (c)1990-2017 Cadro Pty Ltd
;        www.hatchkit.com.au
;-------------------------------------------------------------------------------

;%VERSION=3.0
;%UNITS=MM
*tiles300and603

;%TYPE=MODEL
-90,1.5,-1.5,603,303,600,-1209
0,1.5,-601.5,303,-603,603,-306
0,1.5,-1.5,303,-603,603,-306
180,-1.5,-1.5,-303,603,300,-609
-90,-301.5,-1.5,603,303,600,-1209
-90,-1.5,-1.5,603,303,600,-1209
0,-301.5,-601.5,303,-603,300,-609
-90,604.5,-1.5,603,303,600,-1209

Should load to Revit without issues.

Hugh Adamson

[marko_ribar]

I haven't read your requirements to code for what you exactly need, but I did something for myself based on pattern picture you provided... It's based on my hatch make routines... So here is it (mortar - gaps are equal in x/y directions - I haven't dive even more in the task as I think it's good and as it is now)...

(defun c:hm-2platesrun ( / ss ch apth asupppth f ass scal w1 w2 h m )

  (vl-load-com)

  (prompt "\nHATCH MAKE")
  (print)
  (setenv "MaxHatch" "10000000")
  (prompt "\nSelect boundary...")
  (setq ss (ssget))
  (print)
  (if (null *w1*)
    (progn
      (initget 7)
      (setq w1 (getdist "\nPick or specify width of 1st plate : "))
      (setq *w1* w1)
    )
    (progn
      (initget 6)
      (setq w1 (getdist (strcat "\nPick or specify width 1st plate <" (rtos *w1* 2 8) "> : ")))
      (if (null w1)
        (setq w1 *w1*)
        (setq *w1* w1)
      )
    )
  )
  (if (null *w2*)
    (progn
      (initget 7)
      (setq w2 (getdist "\nPick or specify width of next adjacent plate : "))
      (setq *w2* w2)
    )
    (progn
      (initget 6)
      (setq w2 (getdist (strcat "\nPick or specify width of next adjacent plate <" (rtos *w2* 2 8) "> : ")))
      (if (null w2)
        (setq w2 *w2*)
        (setq *w2* w2)
      )
    )
  )
  (if (null *h*)
    (progn
      (initget 7)
      (setq h (getdist "\nPick or specify height of plates : "))
      (setq *h* h)
    )
    (progn
      (initget 6)
      (setq h (getdist (strcat "\nPick or specify height of plates <" (rtos *h* 2 8) "> : ")))
      (if (null h)
        (setq h *h*)
        (setq *h* h)
      )
    )
  )
  (initget "Yes No")
  (setq ch (getkword "\nDo you want to implement mortar in hatch pattern [Yes/No] <Yes> : "))
  (if (null ch)
    (setq ch "Yes")
  )
  (if (= ch "Yes")
    (progn
      (alert "Width and height of plates will be reduced according to mortar width")
      (if (null *m*)
        (progn
          (initget 7)
          (setq m (getdist "\nPick or specify width of mortar of hatch pattern : "))
          (setq *m* m)
        )
        (progn
          (initget 6)
          (setq m (getdist (strcat "\nPick or specify width of mortar of hatch pattern <" (rtos *m* 2 8) "> : ")))
          (if (null m)
            (setq m *m*)
            (setq *m* m)
          )
        )
      )
    )
  )
  (setq apth (vla-get-path (vlax-get-acad-object)))
  (setq asupppth (strcat apth "\\support"))
  (setq f (open (strcat asupppth "\\hm-2platesrun.pat") "w"))
  (write-line "*HM-2PLATESRUN,HM-2PLATESRUN" f)
  (cond
    ( (eq ch "No")
      (write-line (strcat "0," (rtos (/ 0 2) 2 8) "," (rtos (/ 0 2) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 0) 2 8) "," (rtos (- (+ w2 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (/ 0 2) 2 8) "," (rtos (- h (/ 0 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 0) 2 8) "," (rtos (- (+ w2 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w1 (/ 0 2)) 2 8) "," (rtos (/ 0 2) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 0) 2 8) "," (rtos (- (+ w1 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w1 (/ 0 2)) 2 8) "," (rtos (- h (/ 0 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 0) 2 8) "," (rtos (- (+ w1 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (/ 0 2) 2 8) "," (rtos (+ h (/ 0 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 0) 2 8) "," (rtos (- (+ w1 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w2 (/ 0 2)) 2 8) "," (rtos (+ h (/ 0 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 0) 2 8) "," (rtos (- (+ w2 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (/ 0 2) 2 8) "," (rtos (- (* 2 h) (/ 0 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 0) 2 8) "," (rtos (- (+ w1 0)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w2 (/ 0 2)) 2 8) "," (rtos (- (* 2 h) (/ 0 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 0) 2 8) "," (rtos (- (+ w2 0)) 2 8)) f)
      (write-line (strcat "90," (rtos (/ 0 2) 2 8) "," (rtos (/ 0 2) 2 8) "," (rtos h 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h 0) 2 8) "," (rtos (- 0) 2 8)) f)
      (write-line (strcat "90," (rtos (- w1 (/ 0 2)) 2 8) "," (rtos (/ 0 2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h 0) 2 8) "," (rtos (- (+ h 0)) 2 8)) f)
      (write-line (strcat "90," (rtos (+ w1 (/ 0 2)) 2 8) "," (rtos (/ 0 2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h 0) 2 8) "," (rtos (- (+ h 0)) 2 8)) f)
      (write-line (strcat "90," (rtos (- w2 (/ 0 2)) 2 8) "," (rtos (+ h (/ 0 2)) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h 0) 2 8) "," (rtos (- (+ h 0)) 2 8)) f)
      (write-line (strcat "90," (rtos (+ w2 (/ 0 2)) 2 8) "," (rtos (+ h (/ 0 2)) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h 0) 2 8) "," (rtos (- (+ h 0)) 2 8)) f)
      (write-line (strcat "90," (rtos (- (+ w1 w2) (/ 0 2)) 2 8) "," (rtos (/ 0 2) 2 8) "," (rtos h 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h 0) 2 8) "," (rtos (- 0) 2 8)) f)
    )
    ( (eq ch "Yes")
      (write-line (strcat "0," (rtos (/ m 2) 2 8) "," (rtos (/ m 2) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 m) 2 8) "," (rtos (- (+ w2 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (/ m 2) 2 8) "," (rtos (- h (/ m 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 m) 2 8) "," (rtos (- (+ w2 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w1 (/ m 2)) 2 8) "," (rtos (/ m 2) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 m) 2 8) "," (rtos (- (+ w1 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w1 (/ m 2)) 2 8) "," (rtos (- h (/ m 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 m) 2 8) "," (rtos (- (+ w1 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (/ m 2) 2 8) "," (rtos (+ h (/ m 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 m) 2 8) "," (rtos (- (+ w1 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w2 (/ m 2)) 2 8) "," (rtos (+ h (/ m 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 m) 2 8) "," (rtos (- (+ w2 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (/ m 2) 2 8) "," (rtos (- (* 2 h) (/ m 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w2 m) 2 8) "," (rtos (- (+ w1 m)) 2 8)) f)
      (write-line (strcat "0," (rtos (+ w2 (/ m 2)) 2 8) "," (rtos (- (* 2 h) (/ m 2)) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (- w1 m) 2 8) "," (rtos (- (+ w2 m)) 2 8)) f)
      (write-line (strcat "90," (rtos (/ m 2) 2 8) "," (rtos (/ m 2) 2 8) "," (rtos h 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h m) 2 8) "," (rtos (- m) 2 8)) f)
      (write-line (strcat "90," (rtos (- w1 (/ m 2)) 2 8) "," (rtos (/ m 2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h m) 2 8) "," (rtos (- (+ h m)) 2 8)) f)
      (write-line (strcat "90," (rtos (+ w1 (/ m 2)) 2 8) "," (rtos (/ m 2) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h m) 2 8) "," (rtos (- (+ h m)) 2 8)) f)
      (write-line (strcat "90," (rtos (- w2 (/ m 2)) 2 8) "," (rtos (+ h (/ m 2)) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h m) 2 8) "," (rtos (- (+ h m)) 2 8)) f)
      (write-line (strcat "90," (rtos (+ w2 (/ m 2)) 2 8) "," (rtos (+ h (/ m 2)) 2 8) "," (rtos (* 2 h) 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h m) 2 8) "," (rtos (- (+ h m)) 2 8)) f)
      (write-line (strcat "90," (rtos (- (+ w1 w2) (/ m 2)) 2 8) "," (rtos (/ m 2) 2 8) "," (rtos h 2 8) "," (rtos (+ w1 w2) 2 8) "," (rtos (- h m) 2 8) "," (rtos (- m) 2 8)) f)
    )
  )
  (close f)
  (initget 1 "Yes No")
  (setq ass (getkword "\nAssociative hatch [Yes/No] ? "))
  (initget 6)
  (setq scal (getreal "\nScale factor of hatch <1.0> : "))
  (if (null scal) 
    (setq scal 1)
  )
  (vl-cmdf "_.-BHATCH" "_S" ss "" "_A" "_A" ass "" "_P" "HM-2PLATESRUN" scal "" "")
  (princ)
)

HTH., Marko Ribar, d.i.a.

[marko_ribar]

I saw you gave kudo and soultion to the offered hatch pattern example, but isn't my version more flexible... All you have to do is spend some time input values and pat file will be created... From that on you would be able to reconstruct it to work with Revit model hatching... If you are interested, I have and Kent's right version (your choice), but I didn't get kudo or any acknowledgement for my efforts... So I am not posting it until I don't get some credit for it, FYI...

M.R.

[DannyNL]

This is the second time I see you fishing for kudos Marko and I probably have missed some other times as well.

Although kudos are nice and show appreciation for one's work, I'm not on this forum for collecting kudos but to help people.

I personally will never, never, hold any possible solution back or hostage because someone didn't give me a kudo and beg for one before posting my solution. Giving kudos is voluntary and should never be a condition before helping anyone no matter what. But that's me.

Just my 2 cents.

PS. you actually say that you will not post your solution until you don't get some appreciation. Well, you don't get it, so why not post it 

[marko_ribar]

Why to post it then, when no one will grant me that I'll get one if I post it... This way I am knowing that I am on right path to get some credits... It's not fishing, I usually do things for my personal purposes, and if I see that I can help I do so, otherwise you wouldn't see no any code that I posted... If you are expecting that someone will voluntarily post his copyrighted material just for publicity I think you are wrong... After all we all do thing for some reasons, I just don't see that anyone is earning for his devotion and spending time giving solutions and explaining problems that evolve through time to grant him/her decent conditions for further research and improvement in both directions and personal and for community...

My 2 cents...

[DannyNL]

And there you go wrong!

I have absolutely no gain whatsoever in helping people and/or posting my code here other than that I make people's life somewhat easier and maybe a bit happier.

That said, if something takes me hours/days/weeks to code I just will not start on it as I code for this forum for fun and in between my other activities. And if you think you put too much time and effort into some code just to give it away for free (kudos, money, coffee, beer, etc.) then you should tell so upfront and not afterwards by stating 'I have a solution but I will not post until you pay me/give me a kudo'. To me that's a really strange mindset.

But back on topic; glad Andrew has a working solution.