Green Mid-Century Walls

Simple geometric patterns are of particular interest to us here at 20th Century 3D, the more so if they are very mid-century.

This design is created with simple rectangles and has as its root the many colorful geometric designs that appeared in the 1950s and 60s. Rectangles such as this seemed to be reminiscent particularly of the 1960s.

The proportions of the rectangles are similar to the sizes of the rectangles used at that time and the colors are taken from the British Standard and so the wallpaper must represent the type of wallpaper that would have been available then.

Using green as a color is very mid-century and it gives the room a very clean and perhaps cool (in the old sense) look. I have to admit that I quite like using green although I’m not sure if it perhaps makes the room look a little too cold.

If it helps anyone, the code is reproduced below even though it is quite long – mainly because there is not a regular pattern to the shapes.

You can also see larger versions of this and our other work on our Flickr page which is here.

PImage bg ;
color marblegreen ;
color popred ; // poppy red
color mgray ; // minerva grey

void setup() {
 size(1000, 1000) ;
 background(#207B2C, 250) ; // yaffle green
 marblegreen = color(#2B3E33) ;
 popred = color(#C8361E) ;
 mgray = color(#B2AEA6) ;
 
 fill(100) ;
 stroke(0) ;

 drawRect01(750, 850, 200, 100) ;
 drawRect02(750, 850, 100, 200) ; 
 
 drawRect01(350, 550, 250, 100) ; 
 drawRect02(450, 500, 100, 200) ;
 
 drawRect01(900, 50, 200, 100) ;
 drawRect01(-100, 50, 200, 100) ; // offset
 drawRect02(950, 100, 100, 200) ;
 drawRect02(-50, 100, 100, 200) ; // offset
 
 drawRect01(200, 750, 200, 150) ; // one big
 
 drawRect01(700, 650, 200, 100) ;
 drawRect02(750, 600, 100, 200) ;
 
 drawRect01(650, 250, 200, 150) ; // one big
 
 drawRect01(500, 50, 200, 100) ;
 drawRect02(430, 20, 100, 200) ;
 drawRect02(630, 20, 100, 200) ; // extra gray
 
 drawRect02(50, 600, 100, 300) ; // big gray
 
 drawRect01(250, 250, 200, 100) ;
 drawRect02(300, 250, 100, 200) ;
 
 drawRect02(450, 850, 200, 100) ;
 drawRect02(-50, 450, 200, 100) ;
 drawRect02(950, 450, 200, 100) ; // offset
 
 drawRect01(175, 100, 200, 100) ; 

 drawSquare(300, 50, 300) ; 
 drawSquare(500, 500, 300) ; 
 drawSquare(-100, 100, 300) ;
 drawSquare(900, 100, 300) ; // offset
 drawSquare(50, 650, 300) ; 
 
}
//-------------------------------------------------------------------------------

 // squares
void drawSquare(int x, int y, int s) {
 stroke(marblegreen, 200) ;
 strokeWeight(9) ;
 noFill() ;
 rect(x, y, s, s, 30) ;
}

 // rects
void drawRect01(int x, int y, int s1, int s2) {
 noStroke() ;
 fill(popred, 200) ;
 rect(x, y, s1, s2, 20) ;
}
 
void drawRect02(int x, int y, int s1, int s2) {
 noStroke() ;
 fill(mgray, 200) ;
 rect(x, y, s1, s2, 20) ;
} 

}

 

Mid-Century Wallpaper With Processing

One thing I have wanted to do ever since I started using Processing for the second time is to make some realistic mid-century wallpaper since this is what 20th century 3D was designed to do.

Those who have looked at earlier posts will realise that I have used the 1960s set inspired by an old television series to showcase this wallcovering. Technically, of course, the room depicts the mid-1960s although the wallpaper tries to create the impression of a 1950s design. No matter, wallpaper designs in those days tended to last from one decade into the next and if the wallpaper was thought saleable it would be kept on the book. I have tried to create the look of early 1950s design through the use of shape and form and also by using realistic mid-century colours.

Above is a small picture of the room and a swatch of pattern, but you can see larger versions of this, along with a detailed view, and our other work on our Flickr page which is here.

Processing Font Fun

We had dreary, miserable, wet weather this weekend and so I took the opportunity to have some font fun with Processing.

The image above shows my mid-century bedroom scene with a font inspired wallpaper. The background is mid-century off-white and the font is Sitka Heading, a Microsoft font created by Matthew Carter, and just the capital letter “T”.

Using this as a wallpaper gives it a look almost of anaglypta, a wall covering that was very popular mid-century, and particularly in the 1960s. Anaglypta wallpaper was a textured wallpaper, usually with swirls or random type patterns, however more structured patterning was also available. As a 3D texture this pattern, I think, looks extremely good on the walls and has a simulated texture that you could almost touch if you could walk into the room.

You can also see larger versions of this along with two other font styles and our other work on our Flickr page which is here.

// complete pattern of Ts
 PFont sitkaH ;
void setup() {
 size(1000, 1000) ;
 background(241, 230, 204) ; // off white
stroke(0, 50) ;
 strokeWeight(1) ;
// ---------------------------------------------------------
sitkaH = createFont("Sitka Heading", 200) ;
textFont(sitkaH) ;
fill(0) ;
for(int i = -7 ; i < width ; i += 100) {
 for(int j = 130 ; j < height ; j += 140) {
 text("T", i, j) ;
 }
 }
 }

A Useful Mid-Century Check

sketch_23_02_3d_800

One thing I have been trying to do is to make realistic looking check patterns primarily as textures for furniture and general furnishings in a 3D program

The big problem is not in making the check pattern, this is usually quite easy, but it is in making the resulting pattern look as though it is a realistic texture for use on 3D surfaces. Usually the end result looks as though it is 2D masquerading as 3D – which of course it is. Even with the use of a drawing program it is not always easy to create textures with a realistic look to them.

With processing, however, it is far easier to make the image look like a texture and hopefully this is what the illustration above and the images on our Flickr page look like. The order to create this image, the bands are made from closely spaced lines which give the appearance of texture. Combined with a background image created in Filter Forge which resembles material, this gives what I think is a quite realistic check for use as a furnishing pattern.

On our Flickr page you can see larger images but also the same pattern in a different color along with some swatches.

If it helps anyone, the code is shown below:

void setup() {
 size(1000, 1000) ;
 PImage bg ;
 bg = loadImage("068.jpg") ; // mable green
 image(bg, 0, 0) ;
 olive = color(#6D5D2F) ;
 stroke(olive, 255) ;
 strokeWeight(1) ;
 for(int i = 0 ; i < 500 ; i+= 2) {
 line(0, 250 + i, 1000, 250 + i) ;
 }
for(int i = 0 ; i < 500 ; i+= 2) {
 line(250 + i, 0, 250 + i, 1000) ;
 }
// perimeter lines acrodss
 chocolate = color(#352522) ;
 strokeWeight(10) ;
 stroke(chocolate, 200) ;
 line(0, 244, 1000, 244) ;
 line(0, 754, 1000, 754) ;
// down
 line(244, 0, 244, 1000) ;
 line(754, 0, 754, 1000) ;
 }

A Useful Mid-Century Plaid

sketch_21_01_3d_800

Plaid patterns are very useful and have been in existence for many years including, of course, a variety of mid-century plaids.

I have to be honest with you and admit that I am very pleased with this design as I have tried over the years to make check and plaid patterns in both Adobe Illustrator and other drawing programs that I use without a lot of success. However, I was pleasantly surprised to find that it was quite easy to make the pattern in Processing – after a little trial and error to get the rectangles to fit. There is nothing special about my scrappy coding and if it helps anyone I reproduce it below.

// sketch 21
 void setup() {
 size(1000, 1000) ;
 background(#187198, 255) ; // Pacific blue
 // green
 noStroke() ;
 fill(#008C50, 150) ; // Paris green
 rect(400, 0, 200, 1000) ;
 rect(0, 400, 1000, 200) ;
 // black
 noStroke() ;
 fill(#2B3E33, 150) ; // marble green
 rect(600, 0, 40, 1000) ;
 rect(360, 0, 40, 1000) ;
 rect(0, 360, 1000, 40) ;
 rect(0, 600, 1000, 40) ;
 // red
 noStroke() ;
 fill(#92252A, 150) ; // post office red
 rect(480, 0, 40, 1000) ;
 rect(0, 480, 1000, 40) ;
 // yellow
 noStroke() ;
 fill(#F0DA5E, 100) ; // jasmine
 rect(0, -20, 1040, 40) ;
 rect(0, 980, 1000, 40) ;
 rect(-20, 0, 40, 1000) ;
 rect(980, 0, 40, 1000) ;
 }

On our Flickr page, which is here, there are larger versions of images together with swatches and a different colour variation. Note that sketch 21 does not use a background image where sketch 22 (see it on Flickr) does use a background image in maroon made to resemble a fabric using Filter Forge. It interesting to compare the effect that a background image makes.

A Furnishing Fabric

sketch_18_01_3dfiv_800

One advantage of Processing is that it produces quite complex patterns quickly and easily and the result of this is shown in this furnishing example.

To produce this pattern conventionally would take quite some time although the pattern is easy to make in Processing and there is also the advantage that it is simple to change the colours and the shapes.

I used a different set in Cinema 4D and once again I was extremely pleased with the result having created perhaps one of the better furnishing patterns that we create here. Just a small image is shown above with a full size image on Flickr along with a detail image which shows the pattern more clearly as well as the Swatch – the link is below.

You can also see larger versions of this and our other work on our Flickr page which is here.

A Dual Use Mid-Century Fabric

The Processing Java environment allows, amongst other great things, for simple patterns to be easily created and reproduced.

This is one such pattern intended for textiles and which is shown in two variations in the illustrations above. Firstly the curtains are deliberately kept low-key in order to make them lighten and frame the room without catching the eye with too much detail. Once again the colours are taken from the mid-century palette and designed to blend into the image.

The second pattern uses a different colour scheme and is shown as a fabric on the cushions. This pattern is bolder and stronger and intended to draw the eye to the sofa and into the centre of the room. Again the colours are mid-century colours but this time they provide a focus for attention.

The background used for both patterns is a mid-century magnolia created as a texture using Filter Forge and then imported into Processing.

To give you a clearer look at the pattern and at the background there is also a detailed image which shows a close-up of the cushions and the curtains.

On our Flickr page, which is here, there are larger versions of these images together with two swatches showing just the patterns.