Ring Pattern Curtains

Small patterns, particularly the same motif with a colour change, can make a fabric look very mid-century.

This pattern uses interlocking rings with a schematic stone and glow in four different colours and a small repeat to produce a very tidy and interesting fabric. From the outset I intended to use it as a curtain type of fabric and I have used the rather simple curtain set in Cinema 4D.  The observant will note that the format is now HD rather than 4:3.

The design is similar to the sort of designs that were produced mid-century and to aid the look the colors are taken from the British Standard colors in use at the time.

The actual pattern was coded in Processing using rather a lot of trial and error and the shape is used as a function which is repeated four times, one for each color. Yes, I know, there are more sophisticated ways to code it but I was interested in producing artistic results rather than coding. Because of this, the file is too long (and boring) to reproduce with this post but if anyone would like the file then I will be happy to send it to them.

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

Mid-Century Wallpaper


Large geometric patterns are of particular interest here at 20th Century 3D especially when they resemble those from the 1960s decade.

This is the mid-century living room set that I have used on many other occasions and here it shows off perfectly a mid-century wallpaper using colours that were in use at the time.

The effectiveness is to make the room an eye-catching room and give it a very authentic feel. As with many of the recent patterns shown here recently, this design was made with Processing and the code is shown below.

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

color brass ;
 color rcream ; // rich cream
void setup() {
 size(1000, 1000) ;
 // colors
 brass = color(#DBA20D) ;
 rcream = color(#E7C895) ;
background(brass, 200) ;
 //noStroke() ;
 stroke(0) ;
 strokeWeight(2) ;
 ellipseMode(CENTER) ;
 fill(rcream, 255) ; // off white
 ellipse(0, 0, 1000, 1000) ;
 ellipse(1000, 0, 1000, 1000) ;
 ellipse(0, 1000, 1000, 1000) ;
 ellipse(1000, 1000, 1000, 1000) ;
 }

Two Color Wall Tiles

2color_03

Wall tiles can look good as just one color but, as someone once said, what is better than one color – well, it’s two colors!

Following on from the tiles that I posted earlier, these are two tiles which use simple code based on the recursive function in the book Processing: Creative Coding by Ira Greenberg and others. I have reproduced the code below if it helps anyone.

The purpose of this is to create two nice looking wall tiles that would be suitable for a kitchen or bathroom and then combine them into a simple two color pattern.

There are a variety of images for this project and it would be best to look at the Flickr page which is here. There you will see the two colors and a representation of how they would look applied to a wall, together with the same wall using both colors.

void setup() {
 size(1000, 1000) ;
 background(91, 160, 173) ; // fiesta blue
 
//fill(24, 113, 152) ; // pacific blue
 fill(172, 173, 21) ; // parakeet
 noStroke() ;
 translate(width/2, height/2) ;
 drawCircle(0, 0, width/2) ;
 rotate(PI/2) ;
 drawCircle(0, 0, width/2) ;
}
void drawCircle(int x, int y, int s) {
 if(s > 2) {
 ellipse(x, y, s, s) ;
 drawCircle(x - s/2, y, s/2) ;
 drawCircle(x + s/2, y, s/2) ;
 }
}

Mid-Century Influenced Wall Tiles

One thing that characterizes life in the mid-century, at least in the UK, was the upsurge in DIY.

This began a trend, which exists to this day, for householders to modify, convert or beautify their homes with everything from simple wallpaper or paint all the way to major structural alteration and additions. Whilst this is not for all, something that many people have attempted is to create a tiled wall in perhaps a kitchen or a bathroom.

The pattern for these tiles is similar to the wide variety of tiling patterns which were introduced during the 1950s and 1960s in the UK.

This tile was created with Processing in a matter of minutes and the code, such as it is, is shown below. It is obviously easy to create tiles in different colors and on our Flickr page, which is here, you can see one other color scheme and a two color version.

color eu ;
void setup() {
 size(1000, 1000) ;
 eu = color(#44d7a8) ; // crayola eucalypus
 background(eu) ;
fill(eu) ;
 stroke(255) ;
 strokeWeight(25) ;
 int s1 = 250 ; // size large
 int s2 = 200 ; // size small
 ellipse(250, 250, s1, s1) ;
 ellipse(750, 250, s1, s1) ;
 ellipse(500, 250, s2, s2) ;
 ellipse(750, 500, s2, s2) ;
 ellipse(750, 750, s1, s1) ;
 ellipse(500, 750, s2, s2) ;
 ellipse(250, 750, s1, s1) ;
 ellipse(250, 500, s2, s2) ;
noStroke() ;
 fill(eu) ;
 rect(250, 250, 500, 500) ;
}

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) ;
} 

}

 

Lovely Mid-Century Living Room Curtain Fabric

The 1950s and 60s mid-century decade saw the creation of many new patterns and designs for the home that were used for fabric and paper.

This particular pattern is inspired by designs created in the 1950s in Britain and which I found lend themselves easily to creation by Processing. Unfortunately the Processing file is far too long to include below since I began work by creating the motif separately to go on each of the darker tiles. However I have to admit that the coding was quite simple using copy and paste although, of course, it does end up being a large file.

I had begun by intending that this would be a fabric used for curtain material and so I chose green as the background colour since this would have been a popular colour for most people in that decade. When I finished and was able to construct a scene using my simple mid-century set in Cinema 4D I found that I was pleased with the result.

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

Mid-Century Curtains

The mid-century in the UK saw a lot of fabrics being produced with designs that were based seemingly on almost random looking shapes and forms.

This was a trend that produced some very distinctive looking fabrics and wallpapers and, along with the use of appropriate colours, tends to mark patterns as being mid-century.

This design was made in code with Processing and was intended from the outset as a fabric pattern. It uses the type of shapes that were commonly used and paired with a dark background fabric it makes an ideal material. The set used is a very basic curtain set that was made some time back and which, to be honest, is as good as any other set for showcasing curtain material. The pattern looks an awkward one when seen as a swatch but comes alive when used as material with the other shapes forming a division across the curtain which contrast in well with the shape and colour of the lower forms.

The code is rather long and a little scrappy but I include it below in case it helps anyone.

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

PImage bg ;
 color brass ;
 color pinkb ; // pink beige
 color butterm ; // buttermilk
 color rred ; // reef red
 color cbrown ; // congo brown
 color choc ; // chocolate
void setup() {
 size(1000, 1000) ;
 bg = loadImage("092.jpg") ; // regal red
 image(bg, 0, 0) ;
 // background(255) ;
 // colors
 brass = color(#DBA20D) ;
 pinkb = color(#E09F81) ;
 butterm = color(#E9DAB1) ;
 rred = color(#E07A67) ;
 cbrown = color(#574736) ;
 choc = color(#352522) ;
drawShape01(500, 500) ;
 drawShape01(250, 750) ;
 drawShape02(0, 500) ;
 drawShape02(1000, 500) ; // offset above
 drawShape02(700, 750) ;
 drawShape03(360, 1000) ;
 drawShape03(360, 0) ; // offset above
 drawShape04(0, 700) ;
 drawShape04(0, -300) ; // offset above
 drawShape04(1000, 700) ; // offset above
 drawShape04(1000, -300) ; // offset above
 rect(830, 100, 80, 260, 60, 0, 60, 0) ;
 rect(5, 100, 80, 260, 0, 60, 0, 60) ;
//drawGuides() ;
 // shapes
 stroke(0) ;
 strokeWeight(1) ;
 fill(brass, 180) ;
 // shape01
 beginShape() ;
 curveVertex(360, 150) ; // C1
 curveVertex(210, 100) ; // V1
 curveVertex(170, 200) ; //V2
 curveVertex(210, 300) ; // V3
 curveVertex(360, 250) ; // C2
 vertex(110, 300) ;
 vertex(110, 100) ;
 endShape(CLOSE) ;
 // shape02 add 140 to across to make it 50 away
 beginShape() ;
 vertex(240, 80) ;
 curveVertex(490, 150) ; // C1
 curveVertex(340, 100) ; // V1 curveVertex(310, 200) ; //V2
 curveVertex(340, 320) ; // V3
 curveVertex(490, 250) ; // C2
 vertex(240, 320) ;
 endShape(CLOSE) ;
 // shape03 add 150 to across to make it 50 away
 beginShape() ;
 vertex(380, 300) ;
 vertex(380, 100) ;
 curveVertex(630, 150) ; // C1
 curveVertex(480, 100) ; // V1
 curveVertex(410, 200) ; //V2
 curveVertex(480, 300) ; // V3
 curveVertex(480, 250) ; // C2
endShape(CLOSE) ;
 // shape04 add 150 to across to make it 50 away
 beginShape() ;
 vertex(500, 320) ;
 vertex(500, 80) ;
 curveVertex(580, 150) ; // C1
 curveVertex(630, 100) ; // V1
 curveVertex(590, 200) ; //V2
 curveVertex(630, 320) ; // V3
 curveVertex(630, 250) ; // C2
 endShape(CLOSE) ;
 // shape05 add 150 to across to make it 50 away
 beginShape() ;
 curveVertex(930, 150) ; // C1
 curveVertex(780, 100) ; // V1
 curveVertex(740, 200) ; //V2
 curveVertex(780, 300) ; // V3
 curveVertex(780, 250) ; // C2
 vertex(680, 300) ;
 vertex(680, 100) ;
 endShape(CLOSE) ;
}
//---------------------------------------------------------------
void drawShape01(int x, int y) {
 stroke(butterm, 200) ;
 strokeWeight(7) ;
 fill(pinkb, 150) ;
 rect(x, y, 300, 30) ;
 rect(x, y + 40, 240, 25) ;
 rect(x, y + 75, 180, 20) ;
 rect(x, y + 105, 120, 15) ;
 rect(x, y + 130, 60, 10) ;
 }
void drawShape02(int x, int y) {
 stroke(rred, 250) ;
 strokeWeight(10) ;
 fill(butterm, 200) ;
 ellipse(x, y, 100, 200) ;
 ellipse(x + 100, y, 80, 180) ;
 ellipse(x + 180, y, 60, 160) ;
 }
void drawShape03(int x, int y) {
 stroke(choc, 250) ;
 strokeWeight(5) ;
 fill(pinkb, 250) ;
 line(x, y, x + 300, y) ;
 ellipse(x + 303, y, 30, 30) ;
 line(x, y, x + 300, y - 50) ;
 ellipse(x + 303, y - 50, 30, 30) ;
 line(x, y, x + 300, y + 50) ;
 ellipse(x + 303, y + 50, 30, 30) ;
 // origin ball
 ellipse(x, y, 30, 30) ;
 }
void drawShape04(int x, int y) {
 stroke(choc, 250) ;
 strokeWeight(5) ;
 fill(pinkb, 250) ;
 line(x, y, x, y + 300) ;
 ellipse(x, y + 300, 30, 30) ;
 line(x, y, x + 50, y + 300) ;
 ellipse(x + 50, y + 300, 30, 30) ;
 line(x, y, x - 50, y + 300) ;
 ellipse(x - 50, y + 300, 30, 30) ;
 // origian ball
 ellipse(x, y, 30, 30) ;
 }
//-----------------------------
 void drawGuides() {
 stroke(255, 50) ;
 strokeWeight(1) ;
 // across
 line(250, 0, 250, 1000) ;
 line(500, 0, 500, 1000) ;
 line(750, 0, 750, 1000) ;
 // down
 line(0, 250, 1000, 250) ;
 line(0, 500, 1000, 500) ;
 line(0, 750, 1000, 750) ;
 // reset stroke
 stroke(0) ;
 strokeWeight(1) ;
 }